diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.cs
index 94ae2ac71..85313dc20 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.cs
@@ -3,84150 +3,3910 @@
 
 // <auto-generated />
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 
 /// <summary>
-/// Provides generated Porter-Duff blenders for associated-alpha pixel formats.
+/// Provides the associated-alpha equations consumed by the shared pixel-blending traversal.
 /// </summary>
-internal static partial class AssociatedAlphaPixelBlenders<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
+internal static class AssociatedAlphaPixelBlenderOperators
 {
-
     /// <summary>
-    /// A pixel blender that implements the "NormalSrc" composition equation.
+    /// Applies the "NormalSrc" associated-alpha composition equation.
     /// </summary>
-    public sealed class NormalSrc : AssociatedAlphaPixelBlender<TPixel>
+    public readonly struct NormalSrc : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrc Instance { get; } = new NormalSrc();
-
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalSrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrc(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrc(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrc(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "MultiplySrc" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrc(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrc(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrc(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "AddSrc" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrc(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrc(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrc(background, source, amount);
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
+    /// <summary>
+    /// Applies the "SubtractSrc" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrc(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrc(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrc(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
+    /// <summary>
+    /// Applies the "ScreenSrc" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrc(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrc(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, amount);
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrc(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "DarkenSrc" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrc : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrc(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrc(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrc(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "LightenSrc" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrc(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrc(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrc(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "OverlaySrc" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrc(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrc(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrc(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Applies the "HardLightSrc" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrc(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrc(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrc(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "NormalSrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalSrcAtop : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "MultiplySrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "AddSrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Applies the "SubtractSrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "ScreenSrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenSrcAtop : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "DarkenSrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "LightenSrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background, source, amount);
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Applies the "OverlaySrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "HardLightSrcAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "NormalSrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "MultiplySrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "AddSrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOver(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "SubtractSrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrcOver : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "ScreenSrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "DarkenSrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "LightenSrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "OverlaySrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "HardLightSrcOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrcOver : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "NormalSrcIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "MultiplySrcIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "AddSrcIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcIn(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "SubtractSrcIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplySrc" composition equation.
+    /// Applies the "ScreenSrcIn" associated-alpha composition equation.
     /// </summary>
-    public sealed class MultiplySrc : AssociatedAlphaPixelBlender<TPixel>
+    public readonly struct ScreenSrcIn : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrc Instance { get; } = new MultiplySrc();
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
 
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplySrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "DarkenSrcIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "LightenSrcIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "OverlaySrcIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background, source, amount);
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
+    /// <summary>
+    /// Applies the "HardLightSrcIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
+    /// <summary>
+    /// Applies the "NormalSrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "MultiplySrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrcOut : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "AddSrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddSrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Applies the "SubtractSrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "ScreenSrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenSrcOut : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "DarkenSrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "LightenSrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Applies the "OverlaySrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "HardLightSrcOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrcOut : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "NormalDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDest(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "MultiplyDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDest(background, source, amount);
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Applies the "AddDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDest(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "SubtractDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDest(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "ScreenDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDest(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "DarkenDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDest(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "LightenDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDest(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "OverlayDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDest : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDest(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "HardLightDest" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDest(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "NormalDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "MultiplyDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "AddDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestAtop(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "SubtractDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestAtop : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "ScreenDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "DarkenDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "LightenDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "OverlayDestAtop" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background, source, amount);
     }
 
     /// <summary>
-    /// A pixel blender that implements the "AddSrc" composition equation.
+    /// Applies the "HardLightDestAtop" associated-alpha composition equation.
     /// </summary>
-    public sealed class AddSrc : AssociatedAlphaPixelBlender<TPixel>
+    public readonly struct HardLightDestAtop : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrc Instance { get; } = new AddSrc();
-
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddSrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Applies the "NormalDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOver(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Applies the "MultiplyDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "AddDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOver(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "SubtractDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, amount);
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "ScreenDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background, source, amount);
+    }
 
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "DarkenDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background, source, amount);
+    }
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+    /// <summary>
+    /// Applies the "LightenDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOver(background, source, amount);
+    }
 
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Applies the "OverlayDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "HardLightDestOver" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background, source, amount);
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "NormalDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestIn(background, source, amount);
+    }
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+    /// <summary>
+    /// Applies the "MultiplyDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background, source, amount);
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Applies the "AddDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestIn(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "SubtractDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "ScreenDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "DarkenDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "LightenDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestIn(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "OverlayDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "HardLightDestIn" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestIn : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "NormalDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalDestOut(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "MultiplyDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "AddDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddDestOut(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "SubtractDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "ScreenDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestOut : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "DarkenDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "LightenDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenDestOut(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "OverlayDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "HardLightDestOut" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background, source, amount);
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractSrc" composition equation.
+    /// Applies the "NormalClear" associated-alpha composition equation.
     /// </summary>
-    public sealed class SubtractSrc : AssociatedAlphaPixelBlender<TPixel>
+    public readonly struct NormalClear : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrc Instance { get; } = new SubtractSrc();
-
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractSrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalClear(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Applies the "MultiplyClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyClear(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Applies the "AddClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddClear(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "SubtractClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractClear(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "ScreenClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenClear(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "DarkenClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenClear(background, source, amount);
+    }
 
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "LightenClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenClear(background, source, amount);
+    }
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+    /// <summary>
+    /// Applies the "OverlayClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayClear(background, source, amount);
+    }
 
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Applies the "HardLightClear" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightClear(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "NormalXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.NormalXor(background, source, amount);
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "MultiplyXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.MultiplyXor(background, source, amount);
+    }
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+    /// <summary>
+    /// Applies the "AddXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct AddXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.AddXor(background, source, amount);
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Applies the "SubtractXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.SubtractXor(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "ScreenXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.ScreenXor(background, source, amount);
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "DarkenXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.DarkenXor(background, source, amount);
+    }
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Applies the "LightenXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.LightenXor(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "OverlayXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.OverlayXor(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "HardLightXor" associated-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightXor : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.HardLightXor(background, source, amount);
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+}
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+/// <summary>
+/// Provides associated-alpha pixel blenders for each color and alpha composition pair.
+/// </summary>
+/// <typeparam name="TPixel">The associated-alpha destination pixel format.</typeparam>
+internal static partial class AssociatedAlphaPixelBlenders<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    /// <summary>
+    /// Blends pixels with the "NormalSrc" composition equation.
+    /// </summary>
+    public sealed class NormalSrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrc Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "MultiplySrc" composition equation.
+    /// </summary>
+    public sealed class MultiplySrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplySrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrc Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "AddSrc" composition equation.
+    /// </summary>
+    public sealed class AddSrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrc Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "SubtractSrc" composition equation.
+    /// </summary>
+    public sealed class SubtractSrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractSrc Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "ScreenSrc" composition equation.
+    /// </summary>
+    public sealed class ScreenSrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrc Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "DarkenSrc" composition equation.
+    /// </summary>
+    public sealed class DarkenSrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrc Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "LightenSrc" composition equation.
+    /// </summary>
+    public sealed class LightenSrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrc Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "OverlaySrc" composition equation.
+    /// </summary>
+    public sealed class OverlaySrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlaySrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrc Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "HardLightSrc" composition equation.
+    /// </summary>
+    public sealed class HardLightSrc :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrc Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "NormalSrcAtop" composition equation.
+    /// </summary>
+    public sealed class NormalSrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrcAtop Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "MultiplySrcAtop" composition equation.
+    /// </summary>
+    public sealed class MultiplySrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplySrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrcAtop Instance { get; } = new();
+    }
 
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "AddSrcAtop" composition equation.
+    /// </summary>
+    public sealed class AddSrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrcAtop Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Blends pixels with the "SubtractSrcAtop" composition equation.
+    /// </summary>
+    public sealed class SubtractSrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractSrcAtop Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "ScreenSrcAtop" composition equation.
+    /// </summary>
+    public sealed class ScreenSrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrcAtop Instance { get; } = new();
+    }
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "DarkenSrcAtop" composition equation.
+    /// </summary>
+    public sealed class DarkenSrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrcAtop Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "LightenSrcAtop" composition equation.
+    /// </summary>
+    public sealed class LightenSrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrcAtop Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "OverlaySrcAtop" composition equation.
+    /// </summary>
+    public sealed class OverlaySrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlaySrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrcAtop Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "HardLightSrcAtop" composition equation.
+    /// </summary>
+    public sealed class HardLightSrcAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrcAtop Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "NormalSrcOver" composition equation.
+    /// </summary>
+    public sealed class NormalSrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrcOver Instance { get; } = new();
+    }
 
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "MultiplySrcOver" composition equation.
+    /// </summary>
+    public sealed class MultiplySrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplySrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrcOver Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "AddSrcOver" composition equation.
+    /// </summary>
+    public sealed class AddSrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrcOver Instance { get; } = new();
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "SubtractSrcOver" composition equation.
+    /// </summary>
+    public sealed class SubtractSrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractSrcOver Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "ScreenSrcOver" composition equation.
+    /// </summary>
+    public sealed class ScreenSrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrcOver Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "DarkenSrcOver" composition equation.
+    /// </summary>
+    public sealed class DarkenSrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrcOver Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "LightenSrcOver" composition equation.
+    /// </summary>
+    public sealed class LightenSrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrcOver Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "OverlaySrcOver" composition equation.
+    /// </summary>
+    public sealed class OverlaySrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlaySrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrcOver Instance { get; } = new();
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "HardLightSrcOver" composition equation.
+    /// </summary>
+    public sealed class HardLightSrcOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrcOver Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Blends pixels with the "NormalSrcIn" composition equation.
+    /// </summary>
+    public sealed class NormalSrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrcIn Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "MultiplySrcIn" composition equation.
+    /// </summary>
+    public sealed class MultiplySrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplySrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrcIn Instance { get; } = new();
+    }
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "AddSrcIn" composition equation.
+    /// </summary>
+    public sealed class AddSrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrcIn Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "SubtractSrcIn" composition equation.
+    /// </summary>
+    public sealed class SubtractSrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractSrcIn Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "ScreenSrcIn" composition equation.
+    /// </summary>
+    public sealed class ScreenSrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrcIn Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "DarkenSrcIn" composition equation.
+    /// </summary>
+    public sealed class DarkenSrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrcIn Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "LightenSrcIn" composition equation.
+    /// </summary>
+    public sealed class LightenSrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrcIn Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "OverlaySrcIn" composition equation.
+    /// </summary>
+    public sealed class OverlaySrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlaySrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrcIn Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "HardLightSrcIn" composition equation.
+    /// </summary>
+    public sealed class HardLightSrcIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrcIn Instance { get; } = new();
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "NormalSrcOut" composition equation.
+    /// </summary>
+    public sealed class NormalSrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrcOut Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "MultiplySrcOut" composition equation.
+    /// </summary>
+    public sealed class MultiplySrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplySrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrcOut Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "AddSrcOut" composition equation.
+    /// </summary>
+    public sealed class AddSrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrcOut Instance { get; } = new();
     }
 
     /// <summary>
-    /// A pixel blender that implements the "ScreenSrc" composition equation.
+    /// Blends pixels with the "SubtractSrcOut" composition equation.
     /// </summary>
-    public sealed class ScreenSrc : AssociatedAlphaPixelBlender<TPixel>
+    public sealed class SubtractSrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractSrcOut>
     {
         /// <summary>
-        /// Gets the static instance of this blender.
+        /// Gets the shared blender instance.
         /// </summary>
-        public static ScreenSrc Instance { get; } = new ScreenSrc();
+        public static SubtractSrcOut Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenSrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+    /// <summary>
+    /// Blends pixels with the "ScreenSrcOut" composition equation.
+    /// </summary>
+    public sealed class ScreenSrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrcOut Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+    /// <summary>
+    /// Blends pixels with the "DarkenSrcOut" composition equation.
+    /// </summary>
+    public sealed class DarkenSrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrcOut Instance { get; } = new();
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "LightenSrcOut" composition equation.
+    /// </summary>
+    public sealed class LightenSrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrcOut Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+    /// <summary>
+    /// Blends pixels with the "OverlaySrcOut" composition equation.
+    /// </summary>
+    public sealed class OverlaySrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlaySrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrcOut Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Blends pixels with the "HardLightSrcOut" composition equation.
+    /// </summary>
+    public sealed class HardLightSrcOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrcOut Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "NormalDest" composition equation.
+    /// </summary>
+    public sealed class NormalDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDest Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+    /// <summary>
+    /// Blends pixels with the "MultiplyDest" composition equation.
+    /// </summary>
+    public sealed class MultiplyDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplyDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDest Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrc" composition equation.
-    /// </summary>
-    public sealed class DarkenSrc : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrc Instance { get; } = new DarkenSrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenSrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrc" composition equation.
-    /// </summary>
-    public sealed class LightenSrc : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrc Instance { get; } = new LightenSrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenSrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrc" composition equation.
-    /// </summary>
-    public sealed class OverlaySrc : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrc Instance { get; } = new OverlaySrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlaySrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrc" composition equation.
-    /// </summary>
-    public sealed class HardLightSrc : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrc Instance { get; } = new HardLightSrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightSrc(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcAtop" composition equation.
-    /// </summary>
-    public sealed class NormalSrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcAtop Instance { get; } = new NormalSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcAtop" composition equation.
-    /// </summary>
-    public sealed class MultiplySrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcAtop Instance { get; } = new MultiplySrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcAtop" composition equation.
-    /// </summary>
-    public sealed class AddSrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcAtop Instance { get; } = new AddSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcAtop" composition equation.
-    /// </summary>
-    public sealed class SubtractSrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcAtop Instance { get; } = new SubtractSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcAtop" composition equation.
-    /// </summary>
-    public sealed class ScreenSrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcAtop Instance { get; } = new ScreenSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcAtop" composition equation.
-    /// </summary>
-    public sealed class DarkenSrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcAtop Instance { get; } = new DarkenSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcAtop" composition equation.
-    /// </summary>
-    public sealed class LightenSrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcAtop Instance { get; } = new LightenSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcAtop" composition equation.
-    /// </summary>
-    public sealed class OverlaySrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcAtop Instance { get; } = new OverlaySrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcAtop" composition equation.
-    /// </summary>
-    public sealed class HardLightSrcAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcAtop Instance { get; } = new HardLightSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcOver" composition equation.
-    /// </summary>
-    public sealed class NormalSrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcOver Instance { get; } = new NormalSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcOver" composition equation.
-    /// </summary>
-    public sealed class MultiplySrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcOver Instance { get; } = new MultiplySrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcOver" composition equation.
-    /// </summary>
-    public sealed class AddSrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcOver Instance { get; } = new AddSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddSrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcOver" composition equation.
-    /// </summary>
-    public sealed class SubtractSrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcOver Instance { get; } = new SubtractSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcOver" composition equation.
-    /// </summary>
-    public sealed class ScreenSrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcOver Instance { get; } = new ScreenSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcOver" composition equation.
-    /// </summary>
-    public sealed class DarkenSrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcOver Instance { get; } = new DarkenSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcOver" composition equation.
-    /// </summary>
-    public sealed class LightenSrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcOver Instance { get; } = new LightenSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcOver" composition equation.
-    /// </summary>
-    public sealed class OverlaySrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcOver Instance { get; } = new OverlaySrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcOver" composition equation.
-    /// </summary>
-    public sealed class HardLightSrcOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcOver Instance { get; } = new HardLightSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcIn" composition equation.
-    /// </summary>
-    public sealed class NormalSrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcIn Instance { get; } = new NormalSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcIn" composition equation.
-    /// </summary>
-    public sealed class MultiplySrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcIn Instance { get; } = new MultiplySrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcIn" composition equation.
-    /// </summary>
-    public sealed class AddSrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcIn Instance { get; } = new AddSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddSrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcIn" composition equation.
-    /// </summary>
-    public sealed class SubtractSrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcIn Instance { get; } = new SubtractSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcIn" composition equation.
-    /// </summary>
-    public sealed class ScreenSrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcIn Instance { get; } = new ScreenSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcIn" composition equation.
-    /// </summary>
-    public sealed class DarkenSrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcIn Instance { get; } = new DarkenSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcIn" composition equation.
-    /// </summary>
-    public sealed class LightenSrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcIn Instance { get; } = new LightenSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcIn" composition equation.
-    /// </summary>
-    public sealed class OverlaySrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcIn Instance { get; } = new OverlaySrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcIn" composition equation.
-    /// </summary>
-    public sealed class HardLightSrcIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcIn Instance { get; } = new HardLightSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcOut" composition equation.
-    /// </summary>
-    public sealed class NormalSrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcOut Instance { get; } = new NormalSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcOut" composition equation.
-    /// </summary>
-    public sealed class MultiplySrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcOut Instance { get; } = new MultiplySrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcOut" composition equation.
-    /// </summary>
-    public sealed class AddSrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcOut Instance { get; } = new AddSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddSrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcOut" composition equation.
-    /// </summary>
-    public sealed class SubtractSrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcOut Instance { get; } = new SubtractSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcOut" composition equation.
-    /// </summary>
-    public sealed class ScreenSrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcOut Instance { get; } = new ScreenSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcOut" composition equation.
-    /// </summary>
-    public sealed class DarkenSrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcOut Instance { get; } = new DarkenSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcOut" composition equation.
-    /// </summary>
-    public sealed class LightenSrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcOut Instance { get; } = new LightenSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcOut" composition equation.
-    /// </summary>
-    public sealed class OverlaySrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcOut Instance { get; } = new OverlaySrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcOut" composition equation.
-    /// </summary>
-    public sealed class HardLightSrcOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcOut Instance { get; } = new HardLightSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDest" composition equation.
-    /// </summary>
-    public sealed class NormalDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDest Instance { get; } = new NormalDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDest" composition equation.
-    /// </summary>
-    public sealed class MultiplyDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDest Instance { get; } = new MultiplyDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplyDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDest" composition equation.
-    /// </summary>
-    public sealed class AddDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDest Instance { get; } = new AddDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDest" composition equation.
-    /// </summary>
-    public sealed class SubtractDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDest Instance { get; } = new SubtractDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDest" composition equation.
-    /// </summary>
-    public sealed class ScreenDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDest Instance { get; } = new ScreenDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDest" composition equation.
-    /// </summary>
-    public sealed class DarkenDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDest Instance { get; } = new DarkenDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDest" composition equation.
-    /// </summary>
-    public sealed class LightenDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDest Instance { get; } = new LightenDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDest" composition equation.
-    /// </summary>
-    public sealed class OverlayDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDest Instance { get; } = new OverlayDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlayDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDest" composition equation.
-    /// </summary>
-    public sealed class HardLightDest : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDest Instance { get; } = new HardLightDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightDest(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestAtop" composition equation.
-    /// </summary>
-    public sealed class NormalDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestAtop Instance { get; } = new NormalDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestAtop" composition equation.
-    /// </summary>
-    public sealed class MultiplyDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestAtop Instance { get; } = new MultiplyDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestAtop" composition equation.
-    /// </summary>
-    public sealed class AddDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestAtop Instance { get; } = new AddDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestAtop" composition equation.
-    /// </summary>
-    public sealed class SubtractDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestAtop Instance { get; } = new SubtractDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestAtop" composition equation.
-    /// </summary>
-    public sealed class ScreenDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestAtop Instance { get; } = new ScreenDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestAtop" composition equation.
-    /// </summary>
-    public sealed class DarkenDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestAtop Instance { get; } = new DarkenDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestAtop" composition equation.
-    /// </summary>
-    public sealed class LightenDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestAtop Instance { get; } = new LightenDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestAtop" composition equation.
-    /// </summary>
-    public sealed class OverlayDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestAtop Instance { get; } = new OverlayDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestAtop" composition equation.
-    /// </summary>
-    public sealed class HardLightDestAtop : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestAtop Instance { get; } = new HardLightDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestOver" composition equation.
-    /// </summary>
-    public sealed class NormalDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestOver Instance { get; } = new NormalDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestOver" composition equation.
-    /// </summary>
-    public sealed class MultiplyDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestOver Instance { get; } = new MultiplyDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestOver" composition equation.
-    /// </summary>
-    public sealed class AddDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestOver Instance { get; } = new AddDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestOver" composition equation.
-    /// </summary>
-    public sealed class SubtractDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestOver Instance { get; } = new SubtractDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestOver" composition equation.
-    /// </summary>
-    public sealed class ScreenDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestOver Instance { get; } = new ScreenDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestOver" composition equation.
-    /// </summary>
-    public sealed class DarkenDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestOver Instance { get; } = new DarkenDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestOver" composition equation.
-    /// </summary>
-    public sealed class LightenDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestOver Instance { get; } = new LightenDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestOver" composition equation.
-    /// </summary>
-    public sealed class OverlayDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestOver Instance { get; } = new OverlayDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestOver" composition equation.
-    /// </summary>
-    public sealed class HardLightDestOver : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestOver Instance { get; } = new HardLightDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestIn" composition equation.
-    /// </summary>
-    public sealed class NormalDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestIn Instance { get; } = new NormalDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestIn" composition equation.
-    /// </summary>
-    public sealed class MultiplyDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestIn Instance { get; } = new MultiplyDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestIn" composition equation.
-    /// </summary>
-    public sealed class AddDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestIn Instance { get; } = new AddDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestIn" composition equation.
-    /// </summary>
-    public sealed class SubtractDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestIn Instance { get; } = new SubtractDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestIn" composition equation.
-    /// </summary>
-    public sealed class ScreenDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestIn Instance { get; } = new ScreenDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestIn" composition equation.
-    /// </summary>
-    public sealed class DarkenDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestIn Instance { get; } = new DarkenDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestIn" composition equation.
-    /// </summary>
-    public sealed class LightenDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestIn Instance { get; } = new LightenDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestIn" composition equation.
-    /// </summary>
-    public sealed class OverlayDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestIn Instance { get; } = new OverlayDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestIn" composition equation.
-    /// </summary>
-    public sealed class HardLightDestIn : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestIn Instance { get; } = new HardLightDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestOut" composition equation.
-    /// </summary>
-    public sealed class NormalDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestOut Instance { get; } = new NormalDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestOut" composition equation.
-    /// </summary>
-    public sealed class MultiplyDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestOut Instance { get; } = new MultiplyDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestOut" composition equation.
-    /// </summary>
-    public sealed class AddDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestOut Instance { get; } = new AddDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestOut" composition equation.
-    /// </summary>
-    public sealed class SubtractDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestOut Instance { get; } = new SubtractDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestOut" composition equation.
-    /// </summary>
-    public sealed class ScreenDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestOut Instance { get; } = new ScreenDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestOut" composition equation.
-    /// </summary>
-    public sealed class DarkenDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestOut Instance { get; } = new DarkenDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestOut" composition equation.
-    /// </summary>
-    public sealed class LightenDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestOut Instance { get; } = new LightenDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestOut" composition equation.
-    /// </summary>
-    public sealed class OverlayDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestOut Instance { get; } = new OverlayDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestOut" composition equation.
-    /// </summary>
-    public sealed class HardLightDestOut : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestOut Instance { get; } = new HardLightDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalClear" composition equation.
-    /// </summary>
-    public sealed class NormalClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalClear Instance { get; } = new NormalClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyClear" composition equation.
-    /// </summary>
-    public sealed class MultiplyClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyClear Instance { get; } = new MultiplyClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplyClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddClear" composition equation.
-    /// </summary>
-    public sealed class AddClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddClear Instance { get; } = new AddClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractClear" composition equation.
-    /// </summary>
-    public sealed class SubtractClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractClear Instance { get; } = new SubtractClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenClear" composition equation.
-    /// </summary>
-    public sealed class ScreenClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenClear Instance { get; } = new ScreenClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenClear" composition equation.
-    /// </summary>
-    public sealed class DarkenClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenClear Instance { get; } = new DarkenClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenClear" composition equation.
-    /// </summary>
-    public sealed class LightenClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenClear Instance { get; } = new LightenClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayClear" composition equation.
-    /// </summary>
-    public sealed class OverlayClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayClear Instance { get; } = new OverlayClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlayClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightClear" composition equation.
-    /// </summary>
-    public sealed class HardLightClear : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightClear Instance { get; } = new HardLightClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightClear(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalXor" composition equation.
-    /// </summary>
-    public sealed class NormalXor : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalXor Instance { get; } = new NormalXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.NormalXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyXor" composition equation.
-    /// </summary>
-    public sealed class MultiplyXor : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyXor Instance { get; } = new MultiplyXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.MultiplyXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddXor" composition equation.
-    /// </summary>
-    public sealed class AddXor : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddXor Instance { get; } = new AddXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.AddXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractXor" composition equation.
-    /// </summary>
-    public sealed class SubtractXor : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractXor Instance { get; } = new SubtractXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.SubtractXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenXor" composition equation.
-    /// </summary>
-    public sealed class ScreenXor : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenXor Instance { get; } = new ScreenXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.ScreenXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenXor" composition equation.
-    /// </summary>
-    public sealed class DarkenXor : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenXor Instance { get; } = new DarkenXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.DarkenXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenXor" composition equation.
-    /// </summary>
-    public sealed class LightenXor : AssociatedAlphaPixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenXor Instance { get; } = new LightenXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.LightenXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "AddDest" composition equation.
+    /// </summary>
+    public sealed class AddDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDest Instance { get; } = new();
     }
 
     /// <summary>
-    /// A pixel blender that implements the "OverlayXor" composition equation.
+    /// Blends pixels with the "SubtractDest" composition equation.
     /// </summary>
-    public sealed class OverlayXor : AssociatedAlphaPixelBlender<TPixel>
+    public sealed class SubtractDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractDest>
     {
         /// <summary>
-        /// Gets the static instance of this blender.
+        /// Gets the shared blender instance.
         /// </summary>
-        public static OverlayXor Instance { get; } = new OverlayXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.OverlayXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        public static SubtractDest Instance { get; } = new();
     }
 
     /// <summary>
-    /// A pixel blender that implements the "HardLightXor" composition equation.
+    /// Blends pixels with the "ScreenDest" composition equation.
     /// </summary>
-    public sealed class HardLightXor : AssociatedAlphaPixelBlender<TPixel>
+    public sealed class ScreenDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenDest>
     {
         /// <summary>
-        /// Gets the static instance of this blender.
+        /// Gets the shared blender instance.
         /// </summary>
-        public static HardLightXor Instance { get; } = new HardLightXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.HardLightXor(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        public static ScreenDest Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "DarkenDest" composition equation.
+    /// </summary>
+    public sealed class DarkenDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDest Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "LightenDest" composition equation.
+    /// </summary>
+    public sealed class LightenDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDest Instance { get; } = new();
+    }
 
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "OverlayDest" composition equation.
+    /// </summary>
+    public sealed class OverlayDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlayDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDest Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "HardLightDest" composition equation.
+    /// </summary>
+    public sealed class HardLightDest :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDest Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+    /// <summary>
+    /// Blends pixels with the "NormalDestAtop" composition equation.
+    /// </summary>
+    public sealed class NormalDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDestAtop Instance { get; } = new();
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "MultiplyDestAtop" composition equation.
+    /// </summary>
+    public sealed class MultiplyDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplyDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDestAtop Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "AddDestAtop" composition equation.
+    /// </summary>
+    public sealed class AddDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDestAtop Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "SubtractDestAtop" composition equation.
+    /// </summary>
+    public sealed class SubtractDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractDestAtop Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "ScreenDestAtop" composition equation.
+    /// </summary>
+    public sealed class ScreenDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenDestAtop Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "DarkenDestAtop" composition equation.
+    /// </summary>
+    public sealed class DarkenDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDestAtop Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "LightenDestAtop" composition equation.
+    /// </summary>
+    public sealed class LightenDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDestAtop Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "OverlayDestAtop" composition equation.
+    /// </summary>
+    public sealed class OverlayDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlayDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDestAtop Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "HardLightDestAtop" composition equation.
+    /// </summary>
+    public sealed class HardLightDestAtop :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDestAtop Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "NormalDestOver" composition equation.
+    /// </summary>
+    public sealed class NormalDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDestOver Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "MultiplyDestOver" composition equation.
+    /// </summary>
+    public sealed class MultiplyDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplyDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDestOver Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+    /// <summary>
+    /// Blends pixels with the "AddDestOver" composition equation.
+    /// </summary>
+    public sealed class AddDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDestOver Instance { get; } = new();
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "SubtractDestOver" composition equation.
+    /// </summary>
+    public sealed class SubtractDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractDestOver Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "ScreenDestOver" composition equation.
+    /// </summary>
+    public sealed class ScreenDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenDestOver Instance { get; } = new();
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "DarkenDestOver" composition equation.
+    /// </summary>
+    public sealed class DarkenDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDestOver Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "LightenDestOver" composition equation.
+    /// </summary>
+    public sealed class LightenDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDestOver Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "OverlayDestOver" composition equation.
+    /// </summary>
+    public sealed class OverlayDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlayDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDestOver Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "HardLightDestOver" composition equation.
+    /// </summary>
+    public sealed class HardLightDestOver :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDestOver Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "NormalDestIn" composition equation.
+    /// </summary>
+    public sealed class NormalDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDestIn Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "MultiplyDestIn" composition equation.
+    /// </summary>
+    public sealed class MultiplyDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplyDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDestIn Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "AddDestIn" composition equation.
+    /// </summary>
+    public sealed class AddDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDestIn Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "SubtractDestIn" composition equation.
+    /// </summary>
+    public sealed class SubtractDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractDestIn Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "ScreenDestIn" composition equation.
+    /// </summary>
+    public sealed class ScreenDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenDestIn Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "DarkenDestIn" composition equation.
+    /// </summary>
+    public sealed class DarkenDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDestIn Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "LightenDestIn" composition equation.
+    /// </summary>
+    public sealed class LightenDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDestIn Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "OverlayDestIn" composition equation.
+    /// </summary>
+    public sealed class OverlayDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlayDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDestIn Instance { get; } = new();
+    }
 
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "HardLightDestIn" composition equation.
+    /// </summary>
+    public sealed class HardLightDestIn :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDestIn Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Blends pixels with the "NormalDestOut" composition equation.
+    /// </summary>
+    public sealed class NormalDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDestOut Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "MultiplyDestOut" composition equation.
+    /// </summary>
+    public sealed class MultiplyDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplyDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDestOut Instance { get; } = new();
+    }
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "AddDestOut" composition equation.
+    /// </summary>
+    public sealed class AddDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDestOut Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "SubtractDestOut" composition equation.
+    /// </summary>
+    public sealed class SubtractDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractDestOut Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "ScreenDestOut" composition equation.
+    /// </summary>
+    public sealed class ScreenDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenDestOut Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "DarkenDestOut" composition equation.
+    /// </summary>
+    public sealed class DarkenDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDestOut Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "LightenDestOut" composition equation.
+    /// </summary>
+    public sealed class LightenDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDestOut Instance { get; } = new();
+    }
 
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "OverlayDestOut" composition equation.
+    /// </summary>
+    public sealed class OverlayDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlayDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDestOut Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "HardLightDestOut" composition equation.
+    /// </summary>
+    public sealed class HardLightDestOut :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDestOut Instance { get; } = new();
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "NormalClear" composition equation.
+    /// </summary>
+    public sealed class NormalClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalClear Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "MultiplyClear" composition equation.
+    /// </summary>
+    public sealed class MultiplyClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplyClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyClear Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "AddClear" composition equation.
+    /// </summary>
+    public sealed class AddClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddClear Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "SubtractClear" composition equation.
+    /// </summary>
+    public sealed class SubtractClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractClear Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "ScreenClear" composition equation.
+    /// </summary>
+    public sealed class ScreenClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenClear Instance { get; } = new();
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "DarkenClear" composition equation.
+    /// </summary>
+    public sealed class DarkenClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenClear Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Blends pixels with the "LightenClear" composition equation.
+    /// </summary>
+    public sealed class LightenClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenClear Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "OverlayClear" composition equation.
+    /// </summary>
+    public sealed class OverlayClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlayClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayClear Instance { get; } = new();
+    }
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "HardLightClear" composition equation.
+    /// </summary>
+    public sealed class HardLightClear :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightClear Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "NormalXor" composition equation.
+    /// </summary>
+    public sealed class NormalXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.NormalXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalXor Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "MultiplyXor" composition equation.
+    /// </summary>
+    public sealed class MultiplyXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.MultiplyXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyXor Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "AddXor" composition equation.
+    /// </summary>
+    public sealed class AddXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.AddXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddXor Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "SubtractXor" composition equation.
+    /// </summary>
+    public sealed class SubtractXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.SubtractXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractXor Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "ScreenXor" composition equation.
+    /// </summary>
+    public sealed class ScreenXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.ScreenXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenXor Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "DarkenXor" composition equation.
+    /// </summary>
+    public sealed class DarkenXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.DarkenXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenXor Instance { get; } = new();
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "LightenXor" composition equation.
+    /// </summary>
+    public sealed class LightenXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.LightenXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenXor Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "OverlayXor" composition equation.
+    /// </summary>
+    public sealed class OverlayXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.OverlayXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayXor Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "HardLightXor" composition equation.
+    /// </summary>
+    public sealed class HardLightXor :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.HardLightXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightXor Instance { get; } = new();
     }
 
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt
index 69426b729..70607feb1 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlenders.Generated.tt
@@ -4,31 +4,19 @@
 #>
 <#@ template debug="false" hostspecific="false" language="C#" #>
 <#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
 <#@ output extension=".cs" #>
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // <auto-generated />
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 
-/// <summary>
-/// Provides generated Porter-Duff blenders for associated-alpha pixel formats.
-/// </summary>
-internal static partial class AssociatedAlphaPixelBlenders<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
-{
-
 <#
-var composers = new []{
+var composers = new []
+{
     "Src",
     "SrcAtop",
     "SrcOver",
@@ -43,7 +31,8 @@ var composers = new []{
     "Xor",
 };
 
-var blenders = new []{
+var blenders = new []
+{
     "Normal",
     "Multiply",
     "Add",
@@ -52,796 +41,79 @@ var blenders = new []{
     "Darken",
     "Lighten",
     "Overlay",
-    "HardLight"
+    "HardLight",
 };
-
-    foreach(var composer in composers) {
-    foreach(var blender in blenders) {
-
-        var blender_composer= $"{blender}{composer}";
+#>
+/// <summary>
+/// Provides the associated-alpha equations consumed by the shared pixel-blending traversal.
+/// </summary>
+internal static class AssociatedAlphaPixelBlenderOperators
+{
+<#
+foreach (var composer in composers)
+{
+    foreach (var blender in blenders)
+    {
+        var blenderComposer = $"{blender}{composer}";
 #>
     /// <summary>
-    /// A pixel blender that implements the "<#= blender_composer#>" composition equation.
+    /// Applies the "<#= blenderComposer #>" associated-alpha composition equation.
     /// </summary>
-    public sealed class <#= blender_composer#> : AssociatedAlphaPixelBlender<TPixel>
+    public readonly struct <#= blenderComposer #> : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static <#=blender_composer#> Instance { get; } = new <#=blender_composer#>();
-
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromAssociatedScaledVector4(AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background.ToAssociatedScaledVector4(), source.ToAssociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => AssociatedAlphaPorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                }
-            }
-        }
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => AssociatedAlphaPorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
+    }
 
-                    Vector256<float> blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+<#
+    }
+}
+#>
+}
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = AssociatedAlphaPorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = AssociatedAlphaPorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+/// <summary>
+/// Provides associated-alpha pixel blenders for each color and alpha composition pair.
+/// </summary>
+/// <typeparam name="TPixel">The associated-alpha destination pixel format.</typeparam>
+internal static partial class AssociatedAlphaPixelBlenders<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+<#
+foreach (var composer in composers)
+{
+    foreach (var blender in blenders)
+    {
+        var blenderComposer = $"{blender}{composer}";
+#>
+    /// <summary>
+    /// Blends pixels with the "<#= blenderComposer #>" composition equation.
+    /// </summary>
+    public sealed class <#= blenderComposer #> :
+        AssociatedAlphaPixelBlender<TPixel, AssociatedAlphaPixelBlenderOperators.<#= blenderComposer #>>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static <#= blenderComposer #> Instance { get; } = new();
     }
 
 <#
     }
 }
-
 #>
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlender{TPixel}.cs b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlender{TPixel,TOperator}.cs
similarity index 67%
rename from src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlender{TPixel}.cs
rename to src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlender{TPixel,TOperator}.cs
index 9c71e97e5..00427308c 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlender{TPixel}.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/AssociatedAlphaPixelBlender{TPixel,TOperator}.cs
@@ -9,11 +9,25 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 /// Provides the vector representation used to blend pixels that store associated alpha.
 /// </summary>
 /// <typeparam name="TPixel">The associated-alpha pixel format.</typeparam>
-internal abstract class AssociatedAlphaPixelBlender<TPixel> : PixelBlender<TPixel>
+/// <typeparam name="TOperator">The Porter-Duff equation.</typeparam>
+internal abstract class AssociatedAlphaPixelBlender<TPixel, TOperator> : PixelBlender<TPixel, TOperator>
     where TPixel : unmanaged, IPixel<TPixel>
+    where TOperator : struct, IPixelBlenderOperator
 {
     private static readonly PixelOperations<TPixel> Operations = PixelOperations<TPixel>.Instance;
 
+    /// <inheritdoc />
+    public sealed override TPixel Blend(TPixel background, TPixel source, float amount)
+    {
+        // Associated RGB and alpha must remain in their stored representation throughout composition.
+        Vector4 result = TOperator.Invoke(
+            background.ToAssociatedScaledVector4(),
+            source.ToAssociatedScaledVector4(),
+            Numerics.Clamp(amount, 0, 1F));
+
+        return TPixel.FromAssociatedScaledVector4(result);
+    }
+
     /// <inheritdoc />
     protected override void ToBlendVector4<TPixelSource>(
         Configuration configuration,
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
index 983508d2d..250d789dd 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
@@ -3,84158 +3,3910 @@
 
 // <auto-generated />
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 
 /// <summary>
-/// Collection of Porter Duff alpha blending functions applying different composition models.
+/// Provides the straight-alpha equations consumed by the shared pixel-blending traversal.
 /// </summary>
-/// <remarks>
-/// These functions are designed to be a general solution for all color cases,
-/// that is, they take in account the alpha value of both the backdrop
-/// and source, and there's no need to alpha-premultiply neither the backdrop
-/// nor the source.
-/// Note there are faster functions for when the backdrop color is known
-/// to be opaque
-/// </remarks>
-internal static class DefaultPixelBlenders<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
+internal static class DefaultPixelBlenderOperators
 {
-
     /// <summary>
-    /// A pixel blender that implements the "NormalSrc" composition equation.
+    /// Applies the "NormalSrc" straight-alpha composition equation.
     /// </summary>
-    public class NormalSrc : PixelBlender<TPixel>
+    public readonly struct NormalSrc : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrc Instance { get; } = new NormalSrc();
-
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalSrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalSrc(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalSrc(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalSrc(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "MultiplySrc" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplySrc(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplySrc(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplySrc(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "AddSrc" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddSrc(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddSrc(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddSrc(background, source, amount);
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
+    /// <summary>
+    /// Applies the "SubtractSrc" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractSrc(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractSrc(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractSrc(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
+    /// <summary>
+    /// Applies the "ScreenSrc" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenSrc(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenSrc(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, amount);
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenSrc(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "DarkenSrc" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrc : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenSrc(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenSrc(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenSrc(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "LightenSrc" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenSrc(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenSrc(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenSrc(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "OverlaySrc" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlaySrc(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlaySrc(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlaySrc(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Applies the "HardLightSrc" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrc : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightSrc(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightSrc(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightSrc(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "NormalSrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalSrcAtop : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalSrcAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "MultiplySrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "AddSrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddSrcAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Applies the "SubtractSrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "ScreenSrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenSrcAtop : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "DarkenSrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "LightenSrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenSrcAtop(background, source, amount);
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Applies the "OverlaySrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "HardLightSrcAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrcAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "NormalSrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalSrcOver(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "MultiplySrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplySrcOver(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "AddSrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddSrcOver(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddSrcOver(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddSrcOver(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "SubtractSrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrcOver : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractSrcOver(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "ScreenSrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenSrcOver(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "DarkenSrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenSrcOver(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "LightenSrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenSrcOver(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "OverlaySrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrcOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlaySrcOver(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "HardLightSrcOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrcOver : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightSrcOver(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "NormalSrcIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalSrcIn(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "MultiplySrcIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplySrcIn(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "AddSrcIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddSrcIn(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddSrcIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddSrcIn(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "SubtractSrcIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractSrcIn(background, source, amount);
     }
 
     /// <summary>
-    /// A pixel blender that implements the "MultiplySrc" composition equation.
+    /// Applies the "ScreenSrcIn" straight-alpha composition equation.
     /// </summary>
-    public class MultiplySrc : PixelBlender<TPixel>
+    public readonly struct ScreenSrcIn : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrc Instance { get; } = new MultiplySrc();
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
 
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplySrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenSrcIn(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "DarkenSrcIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenSrcIn(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "LightenSrcIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenSrcIn(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "OverlaySrcIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlaySrcIn(background, source, amount);
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
+    /// <summary>
+    /// Applies the "HardLightSrcIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrcIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightSrcIn(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
+    /// <summary>
+    /// Applies the "NormalSrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalSrcOut(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "MultiplySrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplySrcOut : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplySrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "AddSrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddSrcOut(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddSrcOut(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddSrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Applies the "SubtractSrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractSrcOut(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "ScreenSrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenSrcOut : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenSrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "DarkenSrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenSrcOut(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "LightenSrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenSrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenSrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Applies the "OverlaySrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlaySrcOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlaySrcOut(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "HardLightSrcOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightSrcOut : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightSrcOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "NormalDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDest(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalDest(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalDest(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "MultiplyDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDest(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDest(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDest(background, source, amount);
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Applies the "AddDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDest(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddDest(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddDest(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "SubtractDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDest(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDest(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDest(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "ScreenDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDest(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDest(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDest(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "DarkenDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDest(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDest(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDest(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "LightenDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDest(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenDest(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenDest(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "OverlayDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDest : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDest(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDest(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDest(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "HardLightDest" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDest : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDest(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDest(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDest(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "NormalDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalDestAtop(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "MultiplyDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "AddDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDestAtop(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddDestAtop(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddDestAtop(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "SubtractDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestAtop : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDestAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "ScreenDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDestAtop(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "DarkenDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDestAtop(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "LightenDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenDestAtop(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "OverlayDestAtop" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestAtop : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDestAtop(background, source, amount);
     }
 
     /// <summary>
-    /// A pixel blender that implements the "AddSrc" composition equation.
+    /// Applies the "HardLightDestAtop" straight-alpha composition equation.
     /// </summary>
-    public class AddSrc : PixelBlender<TPixel>
+    public readonly struct HardLightDestAtop : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrc Instance { get; } = new AddSrc();
-
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddSrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDestAtop(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Applies the "NormalDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDestOver(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalDestOver(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalDestOver(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Applies the "MultiplyDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDestOver(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "AddDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDestOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddDestOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddDestOver(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "SubtractDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDestOver(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source, amount);
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "ScreenDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDestOver(background, source, amount);
+    }
 
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "DarkenDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDestOver(background, source, amount);
+    }
 
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+    /// <summary>
+    /// Applies the "LightenDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDestOver(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenDestOver(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenDestOver(background, source, amount);
+    }
 
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Applies the "OverlayDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDestOver(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "HardLightDestOver" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestOver : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDestOver(background, source, amount);
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "NormalDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDestIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalDestIn(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalDestIn(background, source, amount);
+    }
 
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+    /// <summary>
+    /// Applies the "MultiplyDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDestIn(background, source, amount);
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Applies the "AddDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDestIn(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddDestIn(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddDestIn(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "SubtractDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDestIn(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "ScreenDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDestIn(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Applies the "DarkenDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDestIn(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "LightenDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDestIn(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenDestIn(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenDestIn(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "OverlayDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestIn : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDestIn(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "HardLightDestIn" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestIn : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
 
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDestIn(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "NormalDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalDestOut(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalDestOut(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalDestOut(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "MultiplyDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyDestOut(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "AddDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddDestOut(background, source, amount);
 
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddDestOut(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddDestOut(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "SubtractDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractDestOut(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "ScreenDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenDestOut : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenDestOut(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Applies the "DarkenDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenDestOut(background, source, amount);
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "LightenDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenDestOut(background, source, amount);
 
-                    Vector512<float> blended = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenDestOut(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenDestOut(background, source, amount);
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Applies the "OverlayDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlayDestOut(background, source, amount);
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "HardLightDestOut" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightDestOut : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.AddSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightDestOut(background, source, amount);
     }
 
     /// <summary>
-    /// A pixel blender that implements the "SubtractSrc" composition equation.
+    /// Applies the "NormalClear" straight-alpha composition equation.
     /// </summary>
-    public class SubtractSrc : PixelBlender<TPixel>
+    public readonly struct NormalClear : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrc Instance { get; } = new SubtractSrc();
-
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractSrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalClear(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalClear(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalClear(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Applies the "MultiplyClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyClear(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyClear(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyClear(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Applies the "AddClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddClear(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddClear(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddClear(background, source, amount);
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Applies the "SubtractClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractClear(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractClear(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractClear(background, source, amount);
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Applies the "ScreenClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenClear(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenClear(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenClear(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "DarkenClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenClear(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenClear(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenClear(background, source, amount);
+    }
 
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "LightenClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenClear(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenClear(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenClear(background, source, amount);
+    }
 
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+    /// <summary>
+    /// Applies the "OverlayClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayClear(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlayClear(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlayClear(background, source, amount);
+    }
 
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Applies the "HardLightClear" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightClear : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightClear(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightClear(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightClear(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "NormalXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct NormalXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.NormalXor(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.NormalXor(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.NormalXor(background, source, amount);
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "MultiplyXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct MultiplyXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.MultiplyXor(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.MultiplyXor(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.MultiplyXor(background, source, amount);
+    }
 
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
+    /// <summary>
+    /// Applies the "AddXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct AddXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.AddXor(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.AddXor(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.AddXor(background, source, amount);
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Applies the "SubtractXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct SubtractXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.SubtractXor(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.SubtractXor(background, source, amount);
 
-                    destinationBase = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.SubtractXor(background, source, amount);
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Applies the "ScreenXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct ScreenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.ScreenXor(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.ScreenXor(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.ScreenXor(background, source, amount);
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Applies the "DarkenXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct DarkenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.DarkenXor(background, source, amount);
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.DarkenXor(background, source, amount);
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.DarkenXor(background, source, amount);
+    }
 
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Applies the "LightenXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct LightenXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.LightenXor(background, source, amount);
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.LightenXor(background, source, amount);
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.LightenXor(background, source, amount);
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Applies the "OverlayXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct OverlayXor : IPixelBlenderOperator
+    {
+        /// <inheritdoc />
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.OverlayXor(background, source, amount);
 
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.OverlayXor(background, source, amount);
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.OverlayXor(background, source, amount);
+    }
 
+    /// <summary>
+    /// Applies the "HardLightXor" straight-alpha composition equation.
+    /// </summary>
+    public readonly struct HardLightXor : IPixelBlenderOperator
+    {
         /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.HardLightXor(background, source, amount);
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+        /// <inheritdoc />
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.HardLightXor(background, source, amount);
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+        /// <inheritdoc />
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.HardLightXor(background, source, amount);
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+}
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+/// <summary>
+/// Provides straight-alpha pixel blenders for each color and alpha composition pair.
+/// </summary>
+/// <typeparam name="TPixel">The destination pixel format.</typeparam>
+internal static class DefaultPixelBlenders<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+    /// <summary>
+    /// Blends pixels with the "NormalSrc" composition equation.
+    /// </summary>
+    public sealed class NormalSrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrc Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "MultiplySrc" composition equation.
+    /// </summary>
+    public sealed class MultiplySrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplySrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrc Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "AddSrc" composition equation.
+    /// </summary>
+    public sealed class AddSrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrc Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "SubtractSrc" composition equation.
+    /// </summary>
+    public sealed class SubtractSrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractSrc Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "ScreenSrc" composition equation.
+    /// </summary>
+    public sealed class ScreenSrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrc Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "DarkenSrc" composition equation.
+    /// </summary>
+    public sealed class DarkenSrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrc Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "LightenSrc" composition equation.
+    /// </summary>
+    public sealed class LightenSrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrc Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "OverlaySrc" composition equation.
+    /// </summary>
+    public sealed class OverlaySrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlaySrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrc Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "HardLightSrc" composition equation.
+    /// </summary>
+    public sealed class HardLightSrc :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrc>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrc Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "NormalSrcAtop" composition equation.
+    /// </summary>
+    public sealed class NormalSrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrcAtop Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "MultiplySrcAtop" composition equation.
+    /// </summary>
+    public sealed class MultiplySrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplySrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrcAtop Instance { get; } = new();
+    }
 
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "AddSrcAtop" composition equation.
+    /// </summary>
+    public sealed class AddSrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrcAtop Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Blends pixels with the "SubtractSrcAtop" composition equation.
+    /// </summary>
+    public sealed class SubtractSrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractSrcAtop Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "ScreenSrcAtop" composition equation.
+    /// </summary>
+    public sealed class ScreenSrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrcAtop Instance { get; } = new();
+    }
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "DarkenSrcAtop" composition equation.
+    /// </summary>
+    public sealed class DarkenSrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrcAtop Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "LightenSrcAtop" composition equation.
+    /// </summary>
+    public sealed class LightenSrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrcAtop Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "OverlaySrcAtop" composition equation.
+    /// </summary>
+    public sealed class OverlaySrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlaySrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrcAtop Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "HardLightSrcAtop" composition equation.
+    /// </summary>
+    public sealed class HardLightSrcAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrcAtop Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "NormalSrcOver" composition equation.
+    /// </summary>
+    public sealed class NormalSrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrcOver Instance { get; } = new();
+    }
 
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "MultiplySrcOver" composition equation.
+    /// </summary>
+    public sealed class MultiplySrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplySrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrcOver Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "AddSrcOver" composition equation.
+    /// </summary>
+    public sealed class AddSrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrcOver Instance { get; } = new();
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "SubtractSrcOver" composition equation.
+    /// </summary>
+    public sealed class SubtractSrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractSrcOver Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "ScreenSrcOver" composition equation.
+    /// </summary>
+    public sealed class ScreenSrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrcOver Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "DarkenSrcOver" composition equation.
+    /// </summary>
+    public sealed class DarkenSrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrcOver Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "LightenSrcOver" composition equation.
+    /// </summary>
+    public sealed class LightenSrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrcOver Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "OverlaySrcOver" composition equation.
+    /// </summary>
+    public sealed class OverlaySrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlaySrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrcOver Instance { get; } = new();
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "HardLightSrcOver" composition equation.
+    /// </summary>
+    public sealed class HardLightSrcOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrcOver Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Blends pixels with the "NormalSrcIn" composition equation.
+    /// </summary>
+    public sealed class NormalSrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrcIn Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "MultiplySrcIn" composition equation.
+    /// </summary>
+    public sealed class MultiplySrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplySrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrcIn Instance { get; } = new();
+    }
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "AddSrcIn" composition equation.
+    /// </summary>
+    public sealed class AddSrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrcIn Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "SubtractSrcIn" composition equation.
+    /// </summary>
+    public sealed class SubtractSrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractSrcIn Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "ScreenSrcIn" composition equation.
+    /// </summary>
+    public sealed class ScreenSrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrcIn Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "DarkenSrcIn" composition equation.
+    /// </summary>
+    public sealed class DarkenSrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrcIn Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "LightenSrcIn" composition equation.
+    /// </summary>
+    public sealed class LightenSrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrcIn Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "OverlaySrcIn" composition equation.
+    /// </summary>
+    public sealed class OverlaySrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlaySrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrcIn Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "HardLightSrcIn" composition equation.
+    /// </summary>
+    public sealed class HardLightSrcIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrcIn Instance { get; } = new();
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "NormalSrcOut" composition equation.
+    /// </summary>
+    public sealed class NormalSrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalSrcOut Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "MultiplySrcOut" composition equation.
+    /// </summary>
+    public sealed class MultiplySrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplySrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplySrcOut Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "AddSrcOut" composition equation.
+    /// </summary>
+    public sealed class AddSrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddSrcOut Instance { get; } = new();
     }
 
     /// <summary>
-    /// A pixel blender that implements the "ScreenSrc" composition equation.
+    /// Blends pixels with the "SubtractSrcOut" composition equation.
     /// </summary>
-    public class ScreenSrc : PixelBlender<TPixel>
+    public sealed class SubtractSrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractSrcOut>
     {
         /// <summary>
-        /// Gets the static instance of this blender.
+        /// Gets the shared blender instance.
         /// </summary>
-        public static ScreenSrc Instance { get; } = new ScreenSrc();
+        public static SubtractSrcOut Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenSrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+    /// <summary>
+    /// Blends pixels with the "ScreenSrcOut" composition equation.
+    /// </summary>
+    public sealed class ScreenSrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenSrcOut Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+    /// <summary>
+    /// Blends pixels with the "DarkenSrcOut" composition equation.
+    /// </summary>
+    public sealed class DarkenSrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenSrcOut Instance { get; } = new();
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "LightenSrcOut" composition equation.
+    /// </summary>
+    public sealed class LightenSrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenSrcOut Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
+    /// <summary>
+    /// Blends pixels with the "OverlaySrcOut" composition equation.
+    /// </summary>
+    public sealed class OverlaySrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlaySrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlaySrcOut Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
+    /// <summary>
+    /// Blends pixels with the "HardLightSrcOut" composition equation.
+    /// </summary>
+    public sealed class HardLightSrcOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightSrcOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightSrcOut Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "NormalDest" composition equation.
+    /// </summary>
+    public sealed class NormalDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDest Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
+    /// <summary>
+    /// Blends pixels with the "MultiplyDest" composition equation.
+    /// </summary>
+    public sealed class MultiplyDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplyDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDest Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrc" composition equation.
-    /// </summary>
-    public class DarkenSrc : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrc Instance { get; } = new DarkenSrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenSrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrc" composition equation.
-    /// </summary>
-    public class LightenSrc : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrc Instance { get; } = new LightenSrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenSrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrc" composition equation.
-    /// </summary>
-    public class OverlaySrc : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrc Instance { get; } = new OverlaySrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlaySrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrc" composition equation.
-    /// </summary>
-    public class HardLightSrc : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrc Instance { get; } = new HardLightSrc();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightSrc(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrc(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrc(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcAtop" composition equation.
-    /// </summary>
-    public class NormalSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcAtop Instance { get; } = new NormalSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalSrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcAtop" composition equation.
-    /// </summary>
-    public class MultiplySrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcAtop Instance { get; } = new MultiplySrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplySrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcAtop" composition equation.
-    /// </summary>
-    public class AddSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcAtop Instance { get; } = new AddSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddSrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcAtop" composition equation.
-    /// </summary>
-    public class SubtractSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcAtop Instance { get; } = new SubtractSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractSrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcAtop" composition equation.
-    /// </summary>
-    public class ScreenSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcAtop Instance { get; } = new ScreenSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenSrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcAtop" composition equation.
-    /// </summary>
-    public class DarkenSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcAtop Instance { get; } = new DarkenSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenSrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcAtop" composition equation.
-    /// </summary>
-    public class LightenSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcAtop Instance { get; } = new LightenSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenSrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcAtop" composition equation.
-    /// </summary>
-    public class OverlaySrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcAtop Instance { get; } = new OverlaySrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlaySrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcAtop" composition equation.
-    /// </summary>
-    public class HardLightSrcAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcAtop Instance { get; } = new HardLightSrcAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightSrcAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcOver" composition equation.
-    /// </summary>
-    public class NormalSrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcOver Instance { get; } = new NormalSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalSrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcOver" composition equation.
-    /// </summary>
-    public class MultiplySrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcOver Instance { get; } = new MultiplySrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplySrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcOver" composition equation.
-    /// </summary>
-    public class AddSrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcOver Instance { get; } = new AddSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddSrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcOver" composition equation.
-    /// </summary>
-    public class SubtractSrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcOver Instance { get; } = new SubtractSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractSrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcOver" composition equation.
-    /// </summary>
-    public class ScreenSrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcOver Instance { get; } = new ScreenSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenSrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcOver" composition equation.
-    /// </summary>
-    public class DarkenSrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcOver Instance { get; } = new DarkenSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenSrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcOver" composition equation.
-    /// </summary>
-    public class LightenSrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcOver Instance { get; } = new LightenSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenSrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcOver" composition equation.
-    /// </summary>
-    public class OverlaySrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcOver Instance { get; } = new OverlaySrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlaySrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcOver" composition equation.
-    /// </summary>
-    public class HardLightSrcOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcOver Instance { get; } = new HardLightSrcOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightSrcOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcIn" composition equation.
-    /// </summary>
-    public class NormalSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcIn Instance { get; } = new NormalSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalSrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcIn" composition equation.
-    /// </summary>
-    public class MultiplySrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcIn Instance { get; } = new MultiplySrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplySrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcIn" composition equation.
-    /// </summary>
-    public class AddSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcIn Instance { get; } = new AddSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddSrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcIn" composition equation.
-    /// </summary>
-    public class SubtractSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcIn Instance { get; } = new SubtractSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractSrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcIn" composition equation.
-    /// </summary>
-    public class ScreenSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcIn Instance { get; } = new ScreenSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenSrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcIn" composition equation.
-    /// </summary>
-    public class DarkenSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcIn Instance { get; } = new DarkenSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenSrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcIn" composition equation.
-    /// </summary>
-    public class LightenSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcIn Instance { get; } = new LightenSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenSrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcIn" composition equation.
-    /// </summary>
-    public class OverlaySrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcIn Instance { get; } = new OverlaySrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlaySrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcIn" composition equation.
-    /// </summary>
-    public class HardLightSrcIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcIn Instance { get; } = new HardLightSrcIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightSrcIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalSrcOut" composition equation.
-    /// </summary>
-    public class NormalSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalSrcOut Instance { get; } = new NormalSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalSrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplySrcOut" composition equation.
-    /// </summary>
-    public class MultiplySrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplySrcOut Instance { get; } = new MultiplySrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplySrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddSrcOut" composition equation.
-    /// </summary>
-    public class AddSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddSrcOut Instance { get; } = new AddSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddSrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractSrcOut" composition equation.
-    /// </summary>
-    public class SubtractSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractSrcOut Instance { get; } = new SubtractSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractSrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenSrcOut" composition equation.
-    /// </summary>
-    public class ScreenSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenSrcOut Instance { get; } = new ScreenSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenSrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenSrcOut" composition equation.
-    /// </summary>
-    public class DarkenSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenSrcOut Instance { get; } = new DarkenSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenSrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenSrcOut" composition equation.
-    /// </summary>
-    public class LightenSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenSrcOut Instance { get; } = new LightenSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenSrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlaySrcOut" composition equation.
-    /// </summary>
-    public class OverlaySrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlaySrcOut Instance { get; } = new OverlaySrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlaySrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlaySrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlaySrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightSrcOut" composition equation.
-    /// </summary>
-    public class HardLightSrcOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightSrcOut Instance { get; } = new HardLightSrcOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightSrcOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightSrcOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightSrcOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDest" composition equation.
-    /// </summary>
-    public class NormalDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDest Instance { get; } = new NormalDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDest" composition equation.
-    /// </summary>
-    public class MultiplyDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDest Instance { get; } = new MultiplyDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplyDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDest" composition equation.
-    /// </summary>
-    public class AddDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDest Instance { get; } = new AddDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDest" composition equation.
-    /// </summary>
-    public class SubtractDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDest Instance { get; } = new SubtractDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDest" composition equation.
-    /// </summary>
-    public class ScreenDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDest Instance { get; } = new ScreenDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDest" composition equation.
-    /// </summary>
-    public class DarkenDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDest Instance { get; } = new DarkenDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDest" composition equation.
-    /// </summary>
-    public class LightenDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDest Instance { get; } = new LightenDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDest" composition equation.
-    /// </summary>
-    public class OverlayDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDest Instance { get; } = new OverlayDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlayDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDest" composition equation.
-    /// </summary>
-    public class HardLightDest : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDest Instance { get; } = new HardLightDest();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightDest(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDest(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDest(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestAtop" composition equation.
-    /// </summary>
-    public class NormalDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestAtop Instance { get; } = new NormalDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestAtop" composition equation.
-    /// </summary>
-    public class MultiplyDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestAtop Instance { get; } = new MultiplyDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplyDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestAtop" composition equation.
-    /// </summary>
-    public class AddDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestAtop Instance { get; } = new AddDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestAtop" composition equation.
-    /// </summary>
-    public class SubtractDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestAtop Instance { get; } = new SubtractDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestAtop" composition equation.
-    /// </summary>
-    public class ScreenDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestAtop Instance { get; } = new ScreenDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestAtop" composition equation.
-    /// </summary>
-    public class DarkenDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestAtop Instance { get; } = new DarkenDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestAtop" composition equation.
-    /// </summary>
-    public class LightenDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestAtop Instance { get; } = new LightenDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestAtop" composition equation.
-    /// </summary>
-    public class OverlayDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestAtop Instance { get; } = new OverlayDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlayDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestAtop" composition equation.
-    /// </summary>
-    public class HardLightDestAtop : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestAtop Instance { get; } = new HardLightDestAtop();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightDestAtop(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestAtop(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestAtop(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestOver" composition equation.
-    /// </summary>
-    public class NormalDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestOver Instance { get; } = new NormalDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestOver" composition equation.
-    /// </summary>
-    public class MultiplyDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestOver Instance { get; } = new MultiplyDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplyDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestOver" composition equation.
-    /// </summary>
-    public class AddDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestOver Instance { get; } = new AddDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestOver" composition equation.
-    /// </summary>
-    public class SubtractDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestOver Instance { get; } = new SubtractDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestOver" composition equation.
-    /// </summary>
-    public class ScreenDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestOver Instance { get; } = new ScreenDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestOver" composition equation.
-    /// </summary>
-    public class DarkenDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestOver Instance { get; } = new DarkenDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestOver" composition equation.
-    /// </summary>
-    public class LightenDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestOver Instance { get; } = new LightenDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestOver" composition equation.
-    /// </summary>
-    public class OverlayDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestOver Instance { get; } = new OverlayDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlayDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestOver" composition equation.
-    /// </summary>
-    public class HardLightDestOver : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestOver Instance { get; } = new HardLightDestOver();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightDestOver(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestOver(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOver(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestIn" composition equation.
-    /// </summary>
-    public class NormalDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestIn Instance { get; } = new NormalDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestIn" composition equation.
-    /// </summary>
-    public class MultiplyDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestIn Instance { get; } = new MultiplyDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplyDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestIn" composition equation.
-    /// </summary>
-    public class AddDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestIn Instance { get; } = new AddDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestIn" composition equation.
-    /// </summary>
-    public class SubtractDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestIn Instance { get; } = new SubtractDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestIn" composition equation.
-    /// </summary>
-    public class ScreenDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestIn Instance { get; } = new ScreenDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestIn" composition equation.
-    /// </summary>
-    public class DarkenDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestIn Instance { get; } = new DarkenDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestIn" composition equation.
-    /// </summary>
-    public class LightenDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestIn Instance { get; } = new LightenDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestIn" composition equation.
-    /// </summary>
-    public class OverlayDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestIn Instance { get; } = new OverlayDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlayDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestIn" composition equation.
-    /// </summary>
-    public class HardLightDestIn : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestIn Instance { get; } = new HardLightDestIn();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightDestIn(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestIn(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestIn(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalDestOut" composition equation.
-    /// </summary>
-    public class NormalDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalDestOut Instance { get; } = new NormalDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyDestOut" composition equation.
-    /// </summary>
-    public class MultiplyDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyDestOut Instance { get; } = new MultiplyDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplyDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddDestOut" composition equation.
-    /// </summary>
-    public class AddDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddDestOut Instance { get; } = new AddDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractDestOut" composition equation.
-    /// </summary>
-    public class SubtractDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractDestOut Instance { get; } = new SubtractDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenDestOut" composition equation.
-    /// </summary>
-    public class ScreenDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenDestOut Instance { get; } = new ScreenDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenDestOut" composition equation.
-    /// </summary>
-    public class DarkenDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenDestOut Instance { get; } = new DarkenDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenDestOut" composition equation.
-    /// </summary>
-    public class LightenDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenDestOut Instance { get; } = new LightenDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayDestOut" composition equation.
-    /// </summary>
-    public class OverlayDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayDestOut Instance { get; } = new OverlayDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlayDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightDestOut" composition equation.
-    /// </summary>
-    public class HardLightDestOut : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightDestOut Instance { get; } = new HardLightDestOut();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightDestOut(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightDestOut(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightDestOut(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalClear" composition equation.
-    /// </summary>
-    public class NormalClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalClear Instance { get; } = new NormalClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyClear" composition equation.
-    /// </summary>
-    public class MultiplyClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyClear Instance { get; } = new MultiplyClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplyClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddClear" composition equation.
-    /// </summary>
-    public class AddClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddClear Instance { get; } = new AddClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractClear" composition equation.
-    /// </summary>
-    public class SubtractClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractClear Instance { get; } = new SubtractClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenClear" composition equation.
-    /// </summary>
-    public class ScreenClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenClear Instance { get; } = new ScreenClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenClear" composition equation.
-    /// </summary>
-    public class DarkenClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenClear Instance { get; } = new DarkenClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenClear" composition equation.
-    /// </summary>
-    public class LightenClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenClear Instance { get; } = new LightenClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "OverlayClear" composition equation.
-    /// </summary>
-    public class OverlayClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static OverlayClear Instance { get; } = new OverlayClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlayClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "HardLightClear" composition equation.
-    /// </summary>
-    public class HardLightClear : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static HardLightClear Instance { get; } = new HardLightClear();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightClear(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.HardLightClear(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightClear(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "NormalXor" composition equation.
-    /// </summary>
-    public class NormalXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static NormalXor Instance { get; } = new NormalXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.NormalXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.NormalXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.NormalXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "MultiplyXor" composition equation.
-    /// </summary>
-    public class MultiplyXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static MultiplyXor Instance { get; } = new MultiplyXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.MultiplyXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.MultiplyXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.MultiplyXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "AddXor" composition equation.
-    /// </summary>
-    public class AddXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static AddXor Instance { get; } = new AddXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.AddXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.AddXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.AddXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "SubtractXor" composition equation.
-    /// </summary>
-    public class SubtractXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static SubtractXor Instance { get; } = new SubtractXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.SubtractXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.SubtractXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.SubtractXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "ScreenXor" composition equation.
-    /// </summary>
-    public class ScreenXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static ScreenXor Instance { get; } = new ScreenXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.ScreenXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.ScreenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.ScreenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "DarkenXor" composition equation.
-    /// </summary>
-    public class DarkenXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static DarkenXor Instance { get; } = new DarkenXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.DarkenXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.DarkenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.DarkenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// A pixel blender that implements the "LightenXor" composition equation.
-    /// </summary>
-    public class LightenXor : PixelBlender<TPixel>
-    {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static LightenXor Instance { get; } = new LightenXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.LightenXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.LightenXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.LightenXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "AddDest" composition equation.
+    /// </summary>
+    public sealed class AddDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDest Instance { get; } = new();
     }
 
     /// <summary>
-    /// A pixel blender that implements the "OverlayXor" composition equation.
+    /// Blends pixels with the "SubtractDest" composition equation.
     /// </summary>
-    public class OverlayXor : PixelBlender<TPixel>
+    public sealed class SubtractDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractDest>
     {
         /// <summary>
-        /// Gets the static instance of this blender.
+        /// Gets the shared blender instance.
         /// </summary>
-        public static OverlayXor Instance { get; } = new OverlayXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.OverlayXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.OverlayXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.OverlayXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+        public static SubtractDest Instance { get; } = new();
     }
 
     /// <summary>
-    /// A pixel blender that implements the "HardLightXor" composition equation.
+    /// Blends pixels with the "ScreenDest" composition equation.
     /// </summary>
-    public class HardLightXor : PixelBlender<TPixel>
+    public sealed class ScreenDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenDest>
     {
         /// <summary>
-        /// Gets the static instance of this blender.
+        /// Gets the shared blender instance.
         /// </summary>
-        public static HardLightXor Instance { get; } = new HardLightXor();
-
-        /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.HardLightXor(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
+        public static ScreenDest Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "DarkenDest" composition equation.
+    /// </summary>
+    public sealed class DarkenDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDest Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "LightenDest" composition equation.
+    /// </summary>
+    public sealed class LightenDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDest Instance { get; } = new();
+    }
 
-                    destinationBase = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "OverlayDest" composition equation.
+    /// </summary>
+    public sealed class OverlayDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlayDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDest Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "HardLightDest" composition equation.
+    /// </summary>
+    public sealed class HardLightDest :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDest>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDest Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+    /// <summary>
+    /// Blends pixels with the "NormalDestAtop" composition equation.
+    /// </summary>
+    public sealed class NormalDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDestAtop Instance { get; } = new();
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "MultiplyDestAtop" composition equation.
+    /// </summary>
+    public sealed class MultiplyDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplyDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDestAtop Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "AddDestAtop" composition equation.
+    /// </summary>
+    public sealed class AddDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDestAtop Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "SubtractDestAtop" composition equation.
+    /// </summary>
+    public sealed class SubtractDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractDestAtop Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "ScreenDestAtop" composition equation.
+    /// </summary>
+    public sealed class ScreenDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenDestAtop Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "DarkenDestAtop" composition equation.
+    /// </summary>
+    public sealed class DarkenDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDestAtop Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "LightenDestAtop" composition equation.
+    /// </summary>
+    public sealed class LightenDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDestAtop Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "OverlayDestAtop" composition equation.
+    /// </summary>
+    public sealed class OverlayDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlayDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDestAtop Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "HardLightDestAtop" composition equation.
+    /// </summary>
+    public sealed class HardLightDestAtop :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDestAtop>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDestAtop Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "NormalDestOver" composition equation.
+    /// </summary>
+    public sealed class NormalDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDestOver Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "MultiplyDestOver" composition equation.
+    /// </summary>
+    public sealed class MultiplyDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplyDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDestOver Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
+    /// <summary>
+    /// Blends pixels with the "AddDestOver" composition equation.
+    /// </summary>
+    public sealed class AddDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDestOver Instance { get; } = new();
+    }
 
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "SubtractDestOver" composition equation.
+    /// </summary>
+    public sealed class SubtractDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractDestOver Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "ScreenDestOver" composition equation.
+    /// </summary>
+    public sealed class ScreenDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenDestOver Instance { get; } = new();
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "DarkenDestOver" composition equation.
+    /// </summary>
+    public sealed class DarkenDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDestOver Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "LightenDestOver" composition equation.
+    /// </summary>
+    public sealed class LightenDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDestOver Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "OverlayDestOver" composition equation.
+    /// </summary>
+    public sealed class OverlayDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlayDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDestOver Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "HardLightDestOver" composition equation.
+    /// </summary>
+    public sealed class HardLightDestOver :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDestOver>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDestOver Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "NormalDestIn" composition equation.
+    /// </summary>
+    public sealed class NormalDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDestIn Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "MultiplyDestIn" composition equation.
+    /// </summary>
+    public sealed class MultiplyDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplyDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDestIn Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "AddDestIn" composition equation.
+    /// </summary>
+    public sealed class AddDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDestIn Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "SubtractDestIn" composition equation.
+    /// </summary>
+    public sealed class SubtractDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractDestIn Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "ScreenDestIn" composition equation.
+    /// </summary>
+    public sealed class ScreenDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenDestIn Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "DarkenDestIn" composition equation.
+    /// </summary>
+    public sealed class DarkenDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDestIn Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "LightenDestIn" composition equation.
+    /// </summary>
+    public sealed class LightenDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDestIn Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "OverlayDestIn" composition equation.
+    /// </summary>
+    public sealed class OverlayDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlayDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDestIn Instance { get; } = new();
+    }
 
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "HardLightDestIn" composition equation.
+    /// </summary>
+    public sealed class HardLightDestIn :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDestIn>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDestIn Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Blends pixels with the "NormalDestOut" composition equation.
+    /// </summary>
+    public sealed class NormalDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalDestOut Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "MultiplyDestOut" composition equation.
+    /// </summary>
+    public sealed class MultiplyDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplyDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyDestOut Instance { get; } = new();
+    }
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "AddDestOut" composition equation.
+    /// </summary>
+    public sealed class AddDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddDestOut Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "SubtractDestOut" composition equation.
+    /// </summary>
+    public sealed class SubtractDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractDestOut Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "ScreenDestOut" composition equation.
+    /// </summary>
+    public sealed class ScreenDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenDestOut Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "DarkenDestOut" composition equation.
+    /// </summary>
+    public sealed class DarkenDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenDestOut Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "LightenDestOut" composition equation.
+    /// </summary>
+    public sealed class LightenDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenDestOut Instance { get; } = new();
+    }
 
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "OverlayDestOut" composition equation.
+    /// </summary>
+    public sealed class OverlayDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlayDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayDestOut Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "HardLightDestOut" composition equation.
+    /// </summary>
+    public sealed class HardLightDestOut :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightDestOut>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightDestOut Instance { get; } = new();
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "NormalClear" composition equation.
+    /// </summary>
+    public sealed class NormalClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalClear Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "MultiplyClear" composition equation.
+    /// </summary>
+    public sealed class MultiplyClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplyClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyClear Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "AddClear" composition equation.
+    /// </summary>
+    public sealed class AddClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddClear Instance { get; } = new();
+    }
 
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
+    /// <summary>
+    /// Blends pixels with the "SubtractClear" composition equation.
+    /// </summary>
+    public sealed class SubtractClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractClear Instance { get; } = new();
+    }
 
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "ScreenClear" composition equation.
+    /// </summary>
+    public sealed class ScreenClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenClear Instance { get; } = new();
+    }
 
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "DarkenClear" composition equation.
+    /// </summary>
+    public sealed class DarkenClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenClear Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
+    /// <summary>
+    /// Blends pixels with the "LightenClear" composition equation.
+    /// </summary>
+    public sealed class LightenClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenClear Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "OverlayClear" composition equation.
+    /// </summary>
+    public sealed class OverlayClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlayClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayClear Instance { get; } = new();
+    }
 
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
+    /// <summary>
+    /// Blends pixels with the "HardLightClear" composition equation.
+    /// </summary>
+    public sealed class HardLightClear :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightClear>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightClear Instance { get; } = new();
+    }
 
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "NormalXor" composition equation.
+    /// </summary>
+    public sealed class NormalXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.NormalXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static NormalXor Instance { get; } = new();
+    }
 
-                    Vector512<float> blended = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
+    /// <summary>
+    /// Blends pixels with the "MultiplyXor" composition equation.
+    /// </summary>
+    public sealed class MultiplyXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.MultiplyXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static MultiplyXor Instance { get; } = new();
+    }
 
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
+    /// <summary>
+    /// Blends pixels with the "AddXor" composition equation.
+    /// </summary>
+    public sealed class AddXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.AddXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static AddXor Instance { get; } = new();
+    }
 
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
+    /// <summary>
+    /// Blends pixels with the "SubtractXor" composition equation.
+    /// </summary>
+    public sealed class SubtractXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.SubtractXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static SubtractXor Instance { get; } = new();
+    }
 
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
+    /// <summary>
+    /// Blends pixels with the "ScreenXor" composition equation.
+    /// </summary>
+    public sealed class ScreenXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.ScreenXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static ScreenXor Instance { get; } = new();
+    }
 
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
+    /// <summary>
+    /// Blends pixels with the "DarkenXor" composition equation.
+    /// </summary>
+    public sealed class DarkenXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.DarkenXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static DarkenXor Instance { get; } = new();
+    }
 
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+    /// <summary>
+    /// Blends pixels with the "LightenXor" composition equation.
+    /// </summary>
+    public sealed class LightenXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.LightenXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static LightenXor Instance { get; } = new();
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.HardLightXor(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+    /// <summary>
+    /// Blends pixels with the "OverlayXor" composition equation.
+    /// </summary>
+    public sealed class OverlayXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.OverlayXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static OverlayXor Instance { get; } = new();
+    }
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.HardLightXor(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+    /// <summary>
+    /// Blends pixels with the "HardLightXor" composition equation.
+    /// </summary>
+    public sealed class HardLightXor :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.HardLightXor>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static HardLightXor Instance { get; } = new();
     }
 
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
index b1d8134ce..99610b7d8 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
@@ -4,39 +4,19 @@
 #>
 <#@ template debug="false" hostspecific="false" language="C#" #>
 <#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
 <#@ output extension=".cs" #>
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 // <auto-generated />
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
 
-/// <summary>
-/// Collection of Porter Duff alpha blending functions applying different composition models.
-/// </summary>
-/// <remarks>
-/// These functions are designed to be a general solution for all color cases,
-/// that is, they take in account the alpha value of both the backdrop
-/// and source, and there's no need to alpha-premultiply neither the backdrop
-/// nor the source.
-/// Note there are faster functions for when the backdrop color is known
-/// to be opaque
-/// </remarks>
-internal static class DefaultPixelBlenders<TPixel>
-    where TPixel : unmanaged, IPixel<TPixel>
-{
-
 <#
-var composers = new []{
+var composers = new []
+{
     "Src",
     "SrcAtop",
     "SrcOver",
@@ -51,7 +31,8 @@ var composers = new []{
     "Xor",
 };
 
-var blenders = new []{
+var blenders = new []
+{
     "Normal",
     "Multiply",
     "Add",
@@ -60,796 +41,79 @@ var blenders = new []{
     "Darken",
     "Lighten",
     "Overlay",
-    "HardLight"
+    "HardLight",
 };
-
-    foreach(var composer in composers) {
-    foreach(var blender in blenders) {
-
-        var blender_composer= $"{blender}{composer}";
+#>
+/// <summary>
+/// Provides the straight-alpha equations consumed by the shared pixel-blending traversal.
+/// </summary>
+internal static class DefaultPixelBlenderOperators
+{
+<#
+foreach (var composer in composers)
+{
+    foreach (var blender in blenders)
+    {
+        var blenderComposer = $"{blender}{composer}";
 #>
     /// <summary>
-    /// A pixel blender that implements the "<#= blender_composer#>" composition equation.
+    /// Applies the "<#= blenderComposer #>" straight-alpha composition equation.
     /// </summary>
-    public class <#= blender_composer#> : PixelBlender<TPixel>
+    public readonly struct <#= blenderComposer #> : IPixelBlenderOperator
     {
-        /// <summary>
-        /// Gets the static instance of this blender.
-        /// </summary>
-        public static <#=blender_composer#> Instance { get; } = new <#=blender_composer#>();
-
         /// <inheritdoc />
-        public override TPixel Blend(TPixel background, TPixel source, float amount)
-        {
-            return TPixel.FromUnassociatedScaledVector4(PorterDuffFunctions.<#=blender_composer#>(background.ToUnassociatedScaledVector4(), source.ToUnassociatedScaledVector4(), Numerics.Clamp(amount, 0, 1)));
-        }
+        public static Vector4 Invoke(Vector4 background, Vector4 source, float amount)
+            => PorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                }
-            }
-        }
+        public static Vector256<float> Invoke(
+            Vector256<float> background,
+            Vector256<float> source,
+            Vector256<float> amount)
+            => PorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
 
         /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    destinationBase = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, float amount, ReadOnlySpan<float> coverage)
-        {
-            amount = Numerics.Clamp(amount, 0, 1);
-
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> opacity = Vector512.Create(amount);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> opacity = Vector256.Create(amount);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, amount);
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(source));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
-
-                    Vector256<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    sourceBase = ref Unsafe.Add(ref sourceBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
-
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void BlendWithCoverageFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, Vector4 source, ReadOnlySpan<float> amount, ReadOnlySpan<float> coverage)
-        {
-            if (Avx512F.IsSupported && destination.Length >= 4)
-            {
-                // Divide by 4 as 4 elements per Vector4 and 16 per Vector512<float>
-                ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector512<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 4u);
-
-                ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector512<float> sourceBase = Vector512.Create(
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W,
-                    source.X, source.Y, source.Z, source.W);
-                Vector512<float> vOne = Vector512.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    float amount0 = amountBase;
-                    float amount1 = Unsafe.Add(ref amountBase, 1);
-                    float amount2 = Unsafe.Add(ref amountBase, 2);
-                    float amount3 = Unsafe.Add(ref amountBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four amount values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> opacity = Vector512.Create(
-                        amount0, amount0, amount0, amount0,
-                        amount1, amount1, amount1, amount1,
-                        amount2, amount2, amount2, amount2,
-                        amount3, amount3, amount3, amount3);
-                    opacity = Vector512.Min(Vector512.Max(Vector512<float>.Zero, opacity), vOne);
-
-                    float coverage0 = coverageBase;
-                    float coverage1 = Unsafe.Add(ref coverageBase, 1);
-                    float coverage2 = Unsafe.Add(ref coverageBase, 2);
-                    float coverage3 = Unsafe.Add(ref coverageBase, 3);
-
-                    // We need to create a Vector512<float> containing the current four coverage values
-                    // taking up each quarter of the Vector512<float> and then clamp them.
-                    Vector512<float> coverageVector = Vector512.Create(
-                        coverage0, coverage0, coverage0, coverage0,
-                        coverage1, coverage1, coverage1, coverage1,
-                        coverage2, coverage2, coverage2, coverage2,
-                        coverage3, coverage3, coverage3, coverage3);
-                    coverageVector = Vector512.Min(Vector512.Max(Vector512<float>.Zero, coverageVector), vOne);
-
-                    Vector512<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 4);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 4);
-                }
-
-                int remainder = Numerics.Modulo4(destination.Length);
-                if (remainder != 0)
-                {
-                    for (int i = destination.Length - remainder; i < destination.Length; i++)
-                    {
-                        Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                        destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                    }
-                }
-            }
-            else if (Avx2.IsSupported && destination.Length >= 2)
-            {
-                // Divide by 2 as 4 elements per Vector4 and 8 per Vector256<float>
-                ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(destination));
-                ref Vector256<float> destinationLast = ref Unsafe.Add(ref destinationBase, (uint)destination.Length / 2u);
-
-                ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref MemoryMarshal.GetReference(background));
-                ref float amountBase = ref MemoryMarshal.GetReference(amount);
-                ref float coverageBase = ref MemoryMarshal.GetReference(coverage);
-
-                Vector256<float> sourceBase = Vector256.Create(source.X, source.Y, source.Z, source.W, source.X, source.Y, source.Z, source.W);
-                Vector256<float> vOne = Vector256.Create(1F);
-
-                while (Unsafe.IsAddressLessThan(ref destinationBase, ref destinationLast))
-                {
-                    // We need to create a Vector256<float> containing the current and next amount values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> opacity = Vector256.Create(
-                        Vector128.Create(amountBase),
-                        Vector128.Create(Unsafe.Add(ref amountBase, 1)));
-                    opacity = Avx.Min(Avx.Max(Vector256<float>.Zero, opacity), vOne);
-
-                    // We need to create a Vector256<float> containing the current and next coverage values
-                    // taking up each half of the Vector256<float> and then clamp them.
-                    Vector256<float> coverageVector = Vector256.Create(
-                        Vector128.Create(coverageBase),
-                        Vector128.Create(Unsafe.Add(ref coverageBase, 1)));
-                    coverageVector = Avx.Min(Avx.Max(Vector256<float>.Zero, coverageVector), vOne);
+        public static Vector512<float> Invoke(
+            Vector512<float> background,
+            Vector512<float> source,
+            Vector512<float> amount)
+            => PorterDuffFunctions.<#= blenderComposer #>(background, source, amount);
+    }
 
-                    Vector256<float> blended = PorterDuffFunctions.<#=blender_composer#>(backgroundBase, sourceBase, opacity);
-                    destinationBase = PorterDuffFunctions.BlendWithCoverage(backgroundBase, blended, coverageVector);
-                    destinationBase = ref Unsafe.Add(ref destinationBase, 1);
-                    backgroundBase = ref Unsafe.Add(ref backgroundBase, 1);
-                    amountBase = ref Unsafe.Add(ref amountBase, 2);
-                    coverageBase = ref Unsafe.Add(ref coverageBase, 2);
-                }
+<#
+    }
+}
+#>
+}
 
-                if (Numerics.Modulo2(destination.Length) != 0)
-                {
-                    // Vector4 fits neatly in pairs. Any overlap has to be equal to 1.
-                    int i = destination.Length - 1;
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-            else
-            {
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Vector4 blended = PorterDuffFunctions.<#=blender_composer#>(background[i], source, Numerics.Clamp(amount[i], 0, 1F));
-                    destination[i] = PorterDuffFunctions.BlendWithCoverage(background[i], blended, Numerics.Clamp(coverage[i], 0, 1F));
-                }
-            }
-        }
+/// <summary>
+/// Provides straight-alpha pixel blenders for each color and alpha composition pair.
+/// </summary>
+/// <typeparam name="TPixel">The destination pixel format.</typeparam>
+internal static class DefaultPixelBlenders<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+{
+<#
+foreach (var composer in composers)
+{
+    foreach (var blender in blenders)
+    {
+        var blenderComposer = $"{blender}{composer}";
+#>
+    /// <summary>
+    /// Blends pixels with the "<#= blenderComposer #>" composition equation.
+    /// </summary>
+    public sealed class <#= blenderComposer #> :
+        DefaultPixelBlender<TPixel, DefaultPixelBlenderOperators.<#= blenderComposer #>>
+    {
+        /// <summary>
+        /// Gets the shared blender instance.
+        /// </summary>
+        public static <#= blenderComposer #> Instance { get; } = new();
     }
 
 <#
     }
 }
-
 #>
 }
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/IPixelBlenderOperator.cs b/src/ImageSharp/PixelFormats/PixelBlenders/IPixelBlenderOperator.cs
new file mode 100644
index 000000000..bdb43e7be
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/IPixelBlenderOperator.cs
@@ -0,0 +1,46 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
+
+/// <summary>
+/// Defines a Porter-Duff equation that can be applied by the shared pixel-blending traversal.
+/// </summary>
+internal interface IPixelBlenderOperator
+{
+    /// <summary>
+    /// Blends one pixel represented by four RGBA lanes.
+    /// </summary>
+    /// <param name="background">The background RGBA lanes.</param>
+    /// <param name="source">The source RGBA lanes.</param>
+    /// <param name="amount">The source opacity in the range 0 through 1.</param>
+    /// <returns>The blended RGBA lanes.</returns>
+    static abstract Vector4 Invoke(Vector4 background, Vector4 source, float amount);
+
+    /// <summary>
+    /// Blends two pixels represented by two consecutive groups of four RGBA lanes.
+    /// </summary>
+    /// <param name="background">The background RGBA lanes.</param>
+    /// <param name="source">The source RGBA lanes.</param>
+    /// <param name="amount">The source opacity repeated across each pixel's four lanes.</param>
+    /// <returns>The blended RGBA lanes.</returns>
+    static abstract Vector256<float> Invoke(
+        Vector256<float> background,
+        Vector256<float> source,
+        Vector256<float> amount);
+
+    /// <summary>
+    /// Blends four pixels represented by four consecutive groups of four RGBA lanes.
+    /// </summary>
+    /// <param name="background">The background RGBA lanes.</param>
+    /// <param name="source">The source RGBA lanes.</param>
+    /// <param name="amount">The source opacity repeated across each pixel's four lanes.</param>
+    /// <returns>The blended RGBA lanes.</returns>
+    static abstract Vector512<float> Invoke(
+        Vector512<float> background,
+        Vector512<float> source,
+        Vector512<float> amount);
+}
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PixelBlender{TPixel,TOperator}.cs b/src/ImageSharp/PixelFormats/PixelBlenders/PixelBlender{TPixel,TOperator}.cs
new file mode 100644
index 000000000..f50151256
--- /dev/null
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PixelBlender{TPixel,TOperator}.cs
@@ -0,0 +1,706 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+
+namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders;
+
+/// <summary>
+/// Applies a statically selected Porter-Duff equation across pixel-vector rows.
+/// </summary>
+/// <typeparam name="TPixel">The destination pixel format.</typeparam>
+/// <typeparam name="TOperator">The Porter-Duff equation.</typeparam>
+internal abstract class PixelBlender<TPixel, TOperator> : PixelBlender<TPixel>
+    where TPixel : unmanaged, IPixel<TPixel>
+    where TOperator : struct, IPixelBlenderOperator
+{
+    /// <inheritdoc />
+    protected sealed override void BlendFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        ReadOnlySpan<Vector4> source,
+        float amount)
+    {
+        // Public entry points validate the row lengths, so all three references can advance in lockstep.
+        int scalarStart = 0;
+        amount = Numerics.Clamp(amount, 0, 1F);
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref Vector4 sourceRef = ref MemoryMarshal.GetReference(source);
+
+        if (Avx512F.IsSupported && destination.Length >= 4)
+        {
+            // A 512-bit register holds four complete RGBA pixels in [R,G,B,A] groups.
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> amountVector = Vector512.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(
+                    Unsafe.Add(ref backgroundBase, i),
+                    Unsafe.Add(ref sourceBase, i),
+                    amountVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Avx2.IsSupported && destination.Length >= 2)
+        {
+            // A 256-bit register holds two complete RGBA pixels in [R,G,B,A] groups.
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> amountVector = Vector256.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(
+                    Unsafe.Add(ref backgroundBase, i),
+                    Unsafe.Add(ref sourceBase, i),
+                    amountVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        // Vector4 is both the scalar pixel representation and the portable SIMD fallback.
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Unsafe.Add(ref destinationRef, (uint)i) = TOperator.Invoke(
+                Unsafe.Add(ref backgroundRef, (uint)i),
+                Unsafe.Add(ref sourceRef, (uint)i),
+                amount);
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        Vector4 source,
+        float amount)
+    {
+        // Public entry points validate the row lengths, so the destination and background advance together.
+        int scalarStart = 0;
+        amount = Numerics.Clamp(amount, 0, 1F);
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+
+        if (Avx512F.IsSupported && destination.Length >= 4)
+        {
+            // Repeat one [R,G,B,A] source group four times to match the four background pixels.
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> sourceVector = CreateVector512(source);
+            Vector512<float> amountVector = Vector512.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(
+                    Unsafe.Add(ref backgroundBase, i),
+                    sourceVector,
+                    amountVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Avx2.IsSupported && destination.Length >= 2)
+        {
+            // Repeat one [R,G,B,A] source group twice to match the two background pixels.
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> sourceVector = CreateVector256(source);
+            Vector256<float> amountVector = Vector256.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(
+                    Unsafe.Add(ref backgroundBase, i),
+                    sourceVector,
+                    amountVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        // The remaining pixel count is at most three after AVX-512 or one after AVX2.
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Unsafe.Add(ref destinationRef, (uint)i) = TOperator.Invoke(
+                Unsafe.Add(ref backgroundRef, (uint)i),
+                source,
+                amount);
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        ReadOnlySpan<Vector4> source,
+        ReadOnlySpan<float> amount)
+    {
+        // Each amount belongs to one pixel and must be repeated across that pixel's four RGBA lanes.
+        int scalarStart = 0;
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref Vector4 sourceRef = ref MemoryMarshal.GetReference(source);
+        ref float amountRef = ref MemoryMarshal.GetReference(amount);
+
+        if (Avx512F.IsSupported && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 4;
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                // Four scalar amounts become four contiguous [a,a,a,a] groups before clamping.
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 4);
+                Vector512<float> amountVector = CreateClampedVector512(ref amountBase);
+
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(
+                    Unsafe.Add(ref backgroundBase, i),
+                    Unsafe.Add(ref sourceBase, i),
+                    amountVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Avx2.IsSupported && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 2;
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                // Two scalar amounts become two contiguous [a,a,a,a] groups before clamping.
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 2);
+                Vector256<float> amountVector = CreateClampedVector256(ref amountBase);
+
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(
+                    Unsafe.Add(ref backgroundBase, i),
+                    Unsafe.Add(ref sourceBase, i),
+                    amountVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Unsafe.Add(ref destinationRef, (uint)i) = TOperator.Invoke(
+                Unsafe.Add(ref backgroundRef, (uint)i),
+                Unsafe.Add(ref sourceRef, (uint)i),
+                Numerics.Clamp(Unsafe.Add(ref amountRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        Vector4 source,
+        ReadOnlySpan<float> amount)
+    {
+        // The source is invariant, while each background pixel has its own independently clamped amount.
+        int scalarStart = 0;
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref float amountRef = ref MemoryMarshal.GetReference(amount);
+
+        if (Avx512F.IsSupported && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> sourceVector = CreateVector512(source);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 4);
+                Vector512<float> amountVector = CreateClampedVector512(ref amountBase);
+
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(
+                    Unsafe.Add(ref backgroundBase, i),
+                    sourceVector,
+                    amountVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Avx2.IsSupported && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> sourceVector = CreateVector256(source);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 2);
+                Vector256<float> amountVector = CreateClampedVector256(ref amountBase);
+
+                Unsafe.Add(ref destinationBase, i) = TOperator.Invoke(
+                    Unsafe.Add(ref backgroundBase, i),
+                    sourceVector,
+                    amountVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Unsafe.Add(ref destinationRef, (uint)i) = TOperator.Invoke(
+                Unsafe.Add(ref backgroundRef, (uint)i),
+                source,
+                Numerics.Clamp(Unsafe.Add(ref amountRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendWithCoverageFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        ReadOnlySpan<Vector4> source,
+        float amount,
+        ReadOnlySpan<float> coverage)
+    {
+        // Coverage mixes the composed result back toward the original background, so it is fused into this pass.
+        int scalarStart = 0;
+        amount = Numerics.Clamp(amount, 0, 1F);
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref Vector4 sourceRef = ref MemoryMarshal.GetReference(source);
+        ref float coverageRef = ref MemoryMarshal.GetReference(coverage);
+
+        if (Avx512F.IsSupported && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> amountVector = Vector512.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector512<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 4);
+                Vector512<float> coverageVector = CreateClampedVector512(ref coverageBase);
+                Vector512<float> blended = TOperator.Invoke(
+                    backgroundVector,
+                    Unsafe.Add(ref sourceBase, i),
+                    amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(
+                    backgroundVector,
+                    blended,
+                    coverageVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Avx2.IsSupported && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> amountVector = Vector256.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector256<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 2);
+                Vector256<float> coverageVector = CreateClampedVector256(ref coverageBase);
+                Vector256<float> blended = TOperator.Invoke(
+                    backgroundVector,
+                    Unsafe.Add(ref sourceBase, i),
+                    amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(
+                    backgroundVector,
+                    blended,
+                    coverageVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Vector4 backgroundPixel = Unsafe.Add(ref backgroundRef, (uint)i);
+            Vector4 blended = TOperator.Invoke(
+                backgroundPixel,
+                Unsafe.Add(ref sourceRef, (uint)i),
+                amount);
+
+            Unsafe.Add(ref destinationRef, (uint)i) = PorterDuffFunctions.BlendWithCoverage(
+                backgroundPixel,
+                blended,
+                Numerics.Clamp(Unsafe.Add(ref coverageRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendWithCoverageFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        Vector4 source,
+        float amount,
+        ReadOnlySpan<float> coverage)
+    {
+        // The constant source is expanded once per selected width and reused for the complete row.
+        int scalarStart = 0;
+        amount = Numerics.Clamp(amount, 0, 1F);
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref float coverageRef = ref MemoryMarshal.GetReference(coverage);
+
+        if (Avx512F.IsSupported && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> sourceVector = CreateVector512(source);
+            Vector512<float> amountVector = Vector512.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector512<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 4);
+                Vector512<float> coverageVector = CreateClampedVector512(ref coverageBase);
+                Vector512<float> blended = TOperator.Invoke(backgroundVector, sourceVector, amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(
+                    backgroundVector,
+                    blended,
+                    coverageVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Avx2.IsSupported && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> sourceVector = CreateVector256(source);
+            Vector256<float> amountVector = Vector256.Create(amount);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector256<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 2);
+                Vector256<float> coverageVector = CreateClampedVector256(ref coverageBase);
+                Vector256<float> blended = TOperator.Invoke(backgroundVector, sourceVector, amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(
+                    backgroundVector,
+                    blended,
+                    coverageVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Vector4 backgroundPixel = Unsafe.Add(ref backgroundRef, (uint)i);
+            Vector4 blended = TOperator.Invoke(backgroundPixel, source, amount);
+
+            Unsafe.Add(ref destinationRef, (uint)i) = PorterDuffFunctions.BlendWithCoverage(
+                backgroundPixel,
+                blended,
+                Numerics.Clamp(Unsafe.Add(ref coverageRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendWithCoverageFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        ReadOnlySpan<Vector4> source,
+        ReadOnlySpan<float> amount,
+        ReadOnlySpan<float> coverage)
+    {
+        // Amount controls composition while coverage controls the final mix with the untouched background.
+        int scalarStart = 0;
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref Vector4 sourceRef = ref MemoryMarshal.GetReference(source);
+        ref float amountRef = ref MemoryMarshal.GetReference(amount);
+        ref float coverageRef = ref MemoryMarshal.GetReference(coverage);
+
+        if (Avx512F.IsSupported && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            ref Vector512<float> sourceBase = ref Unsafe.As<Vector4, Vector512<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 4;
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector512<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 4);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 4);
+                Vector512<float> amountVector = CreateClampedVector512(ref amountBase);
+                Vector512<float> coverageVector = CreateClampedVector512(ref coverageBase);
+                Vector512<float> blended = TOperator.Invoke(
+                    backgroundVector,
+                    Unsafe.Add(ref sourceBase, i),
+                    amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(
+                    backgroundVector,
+                    blended,
+                    coverageVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Avx2.IsSupported && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            ref Vector256<float> sourceBase = ref Unsafe.As<Vector4, Vector256<float>>(ref sourceRef);
+            int vectorCount = destination.Length / 2;
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector256<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 2);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 2);
+                Vector256<float> amountVector = CreateClampedVector256(ref amountBase);
+                Vector256<float> coverageVector = CreateClampedVector256(ref coverageBase);
+                Vector256<float> blended = TOperator.Invoke(
+                    backgroundVector,
+                    Unsafe.Add(ref sourceBase, i),
+                    amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(
+                    backgroundVector,
+                    blended,
+                    coverageVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Vector4 backgroundPixel = Unsafe.Add(ref backgroundRef, (uint)i);
+            Vector4 blended = TOperator.Invoke(
+                backgroundPixel,
+                Unsafe.Add(ref sourceRef, (uint)i),
+                Numerics.Clamp(Unsafe.Add(ref amountRef, (uint)i), 0, 1F));
+
+            Unsafe.Add(ref destinationRef, (uint)i) = PorterDuffFunctions.BlendWithCoverage(
+                backgroundPixel,
+                blended,
+                Numerics.Clamp(Unsafe.Add(ref coverageRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <inheritdoc />
+    protected sealed override void BlendWithCoverageFunction(
+        Span<Vector4> destination,
+        ReadOnlySpan<Vector4> background,
+        Vector4 source,
+        ReadOnlySpan<float> amount,
+        ReadOnlySpan<float> coverage)
+    {
+        // The invariant source is expanded once; only amount and coverage are gathered for each vector batch.
+        int scalarStart = 0;
+
+        ref Vector4 destinationRef = ref MemoryMarshal.GetReference(destination);
+        ref Vector4 backgroundRef = ref MemoryMarshal.GetReference(background);
+        ref float amountRef = ref MemoryMarshal.GetReference(amount);
+        ref float coverageRef = ref MemoryMarshal.GetReference(coverage);
+
+        if (Avx512F.IsSupported && destination.Length >= 4)
+        {
+            ref Vector512<float> destinationBase = ref Unsafe.As<Vector4, Vector512<float>>(ref destinationRef);
+            ref Vector512<float> backgroundBase = ref Unsafe.As<Vector4, Vector512<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 4;
+            Vector512<float> sourceVector = CreateVector512(source);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector512<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 4);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 4);
+                Vector512<float> amountVector = CreateClampedVector512(ref amountBase);
+                Vector512<float> coverageVector = CreateClampedVector512(ref coverageBase);
+                Vector512<float> blended = TOperator.Invoke(backgroundVector, sourceVector, amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(
+                    backgroundVector,
+                    blended,
+                    coverageVector);
+            }
+
+            scalarStart = vectorCount * 4;
+        }
+        else if (Avx2.IsSupported && destination.Length >= 2)
+        {
+            ref Vector256<float> destinationBase = ref Unsafe.As<Vector4, Vector256<float>>(ref destinationRef);
+            ref Vector256<float> backgroundBase = ref Unsafe.As<Vector4, Vector256<float>>(ref backgroundRef);
+            int vectorCount = destination.Length / 2;
+            Vector256<float> sourceVector = CreateVector256(source);
+
+            for (nuint i = 0; i < (uint)vectorCount; i++)
+            {
+                ref Vector256<float> backgroundVector = ref Unsafe.Add(ref backgroundBase, i);
+                ref float amountBase = ref Unsafe.Add(ref amountRef, i * 2);
+                ref float coverageBase = ref Unsafe.Add(ref coverageRef, i * 2);
+                Vector256<float> amountVector = CreateClampedVector256(ref amountBase);
+                Vector256<float> coverageVector = CreateClampedVector256(ref coverageBase);
+                Vector256<float> blended = TOperator.Invoke(backgroundVector, sourceVector, amountVector);
+
+                Unsafe.Add(ref destinationBase, i) = PorterDuffFunctions.BlendWithCoverage(
+                    backgroundVector,
+                    blended,
+                    coverageVector);
+            }
+
+            scalarStart = vectorCount * 2;
+        }
+
+        for (int i = scalarStart; i < destination.Length; i++)
+        {
+            Vector4 backgroundPixel = Unsafe.Add(ref backgroundRef, (uint)i);
+            Vector4 blended = TOperator.Invoke(
+                backgroundPixel,
+                source,
+                Numerics.Clamp(Unsafe.Add(ref amountRef, (uint)i), 0, 1F));
+
+            Unsafe.Add(ref destinationRef, (uint)i) = PorterDuffFunctions.BlendWithCoverage(
+                backgroundPixel,
+                blended,
+                Numerics.Clamp(Unsafe.Add(ref coverageRef, (uint)i), 0, 1F));
+        }
+    }
+
+    /// <summary>
+    /// Repeats one RGBA pixel twice to fill a 256-bit register.
+    /// </summary>
+    /// <param name="pixel">The pixel represented by ordered RGBA lanes.</param>
+    /// <returns>Two consecutive copies of the pixel.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<float> CreateVector256(Vector4 pixel)
+        => Vector256.Create(pixel.X, pixel.Y, pixel.Z, pixel.W, pixel.X, pixel.Y, pixel.Z, pixel.W);
+
+    /// <summary>
+    /// Repeats one RGBA pixel four times to fill a 512-bit register.
+    /// </summary>
+    /// <param name="pixel">The pixel represented by ordered RGBA lanes.</param>
+    /// <returns>Four consecutive copies of the pixel.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<float> CreateVector512(Vector4 pixel)
+        => Vector512.Create(
+            pixel.X,
+            pixel.Y,
+            pixel.Z,
+            pixel.W,
+            pixel.X,
+            pixel.Y,
+            pixel.Z,
+            pixel.W,
+            pixel.X,
+            pixel.Y,
+            pixel.Z,
+            pixel.W,
+            pixel.X,
+            pixel.Y,
+            pixel.Z,
+            pixel.W);
+
+    /// <summary>
+    /// Expands and clamps two per-pixel scalar values for two packed RGBA pixels.
+    /// </summary>
+    /// <param name="values">The first of two contiguous scalar values.</param>
+    /// <returns>Two consecutive groups containing one clamped value in each group's four lanes.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector256<float> CreateClampedVector256(ref float values)
+    {
+        Vector256<float> result = Vector256.Create(
+            Vector128.Create(values),
+            Vector128.Create(Unsafe.Add(ref values, 1)));
+
+        // Amount and coverage share the same public 0..1 contract and therefore the same packed clamp.
+        return Avx.Min(Avx.Max(Vector256<float>.Zero, result), Vector256.Create(1F));
+    }
+
+    /// <summary>
+    /// Expands and clamps four per-pixel scalar values for four packed RGBA pixels.
+    /// </summary>
+    /// <param name="values">The first of four contiguous scalar values.</param>
+    /// <returns>Four consecutive groups containing one clamped value in each group's four lanes.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static Vector512<float> CreateClampedVector512(ref float values)
+    {
+        Vector512<float> result = Vector512.Create(
+            values,
+            values,
+            values,
+            values,
+            Unsafe.Add(ref values, 1),
+            Unsafe.Add(ref values, 1),
+            Unsafe.Add(ref values, 1),
+            Unsafe.Add(ref values, 1),
+            Unsafe.Add(ref values, 2),
+            Unsafe.Add(ref values, 2),
+            Unsafe.Add(ref values, 2),
+            Unsafe.Add(ref values, 2),
+            Unsafe.Add(ref values, 3),
+            Unsafe.Add(ref values, 3),
+            Unsafe.Add(ref values, 3),
+            Unsafe.Add(ref values, 3));
+
+        return Vector512.Min(Vector512.Max(Vector512<float>.Zero, result), Vector512.Create(1F));
+    }
+}
+
+/// <summary>
+/// Applies a statically selected Porter-Duff equation to straight-alpha pixels.
+/// </summary>
+/// <typeparam name="TPixel">The straight-alpha pixel format.</typeparam>
+/// <typeparam name="TOperator">The Porter-Duff equation.</typeparam>
+internal abstract class DefaultPixelBlender<TPixel, TOperator> : PixelBlender<TPixel, TOperator>
+    where TPixel : unmanaged, IPixel<TPixel>
+    where TOperator : struct, IPixelBlenderOperator
+{
+    /// <inheritdoc />
+    public sealed override TPixel Blend(TPixel background, TPixel source, float amount)
+    {
+        // The operator consumes the same unassociated, scaled representation used by the bulk conversion path.
+        Vector4 result = TOperator.Invoke(
+            background.ToUnassociatedScaledVector4(),
+            source.ToUnassociatedScaledVector4(),
+            Numerics.Clamp(amount, 0, 1F));
+
+        return TPixel.FromUnassociatedScaledVector4(result);
+    }
+}
diff --git a/tests/ImageSharp.Benchmarks/PixelBlenders/PixelBlenderTraversalAssembly.cs b/tests/ImageSharp.Benchmarks/PixelBlenders/PixelBlenderTraversalAssembly.cs
new file mode 100644
index 000000000..a8d6095c7
--- /dev/null
+++ b/tests/ImageSharp.Benchmarks/PixelBlenders/PixelBlenderTraversalAssembly.cs
@@ -0,0 +1,327 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.PixelFormats.PixelBlenders;
+
+namespace SixLabors.ImageSharp.Benchmarks.PixelBlenders;
+
+/// <summary>
+/// Exposes every shared pixel-blender traversal shape for assembly inspection.
+/// </summary>
+/// <remarks>
+/// Seven pixels leave three scalar pixels after AVX-512 or one scalar pixel after AVX2, so each
+/// hardware job contains both its widest supported loop and the portable Vector4 remainder.
+/// </remarks>
+[Config(typeof(Config.Analysis))]
+public class PixelBlenderTraversalAssembly
+{
+    private const int Count = 7;
+    private const float Amount = .625F;
+
+    private readonly ExposedNormalSrcOverBlender blender = new();
+    private readonly Vector4[] destination = new Vector4[Count];
+    private readonly Vector4[] background = new Vector4[Count];
+    private readonly Vector4[] source = new Vector4[Count];
+    private readonly float[] amounts = new float[Count];
+    private readonly float[] coverage = new float[Count];
+    private Vector4 constantSource;
+
+    /// <summary>
+    /// Populates all lanes with deterministic, non-constant values.
+    /// </summary>
+    [GlobalSetup]
+    public void Setup()
+    {
+        Random random = new(42);
+
+        for (int i = 0; i < Count; i++)
+        {
+            // Distinct RGBA lanes make incorrect pixel grouping visible in both results and assembly.
+            this.background[i] = CreatePixel(random);
+            this.source[i] = CreatePixel(random);
+            this.amounts[i] = random.NextSingle();
+            this.coverage[i] = random.NextSingle();
+        }
+
+        this.constantSource = CreatePixel(random);
+    }
+
+    /// <summary>
+    /// Blends a source row with one shared amount.
+    /// </summary>
+    /// <returns>The final destination pixel.</returns>
+    [Benchmark]
+    public Vector4 SourceSpanScalarAmount()
+    {
+        this.blender.BlendSourceSpanScalarAmount(
+            this.destination,
+            this.background,
+            this.source,
+            Amount);
+
+        return this.destination[^1];
+    }
+
+    /// <summary>
+    /// Blends a constant source with one shared amount.
+    /// </summary>
+    /// <returns>The final destination pixel.</returns>
+    [Benchmark]
+    public Vector4 ConstantSourceScalarAmount()
+    {
+        this.blender.BlendConstantSourceScalarAmount(
+            this.destination,
+            this.background,
+            this.constantSource,
+            Amount);
+
+        return this.destination[^1];
+    }
+
+    /// <summary>
+    /// Blends a source row with per-pixel amounts.
+    /// </summary>
+    /// <returns>The final destination pixel.</returns>
+    [Benchmark]
+    public Vector4 SourceSpanAmountSpan()
+    {
+        this.blender.BlendSourceSpanAmountSpan(
+            this.destination,
+            this.background,
+            this.source,
+            this.amounts);
+
+        return this.destination[^1];
+    }
+
+    /// <summary>
+    /// Blends a constant source with per-pixel amounts.
+    /// </summary>
+    /// <returns>The final destination pixel.</returns>
+    [Benchmark]
+    public Vector4 ConstantSourceAmountSpan()
+    {
+        this.blender.BlendConstantSourceAmountSpan(
+            this.destination,
+            this.background,
+            this.constantSource,
+            this.amounts);
+
+        return this.destination[^1];
+    }
+
+    /// <summary>
+    /// Blends a source row with one shared amount and per-pixel coverage.
+    /// </summary>
+    /// <returns>The final destination pixel.</returns>
+    [Benchmark]
+    public Vector4 SourceSpanScalarAmountCoverage()
+    {
+        this.blender.BlendSourceSpanScalarAmountCoverage(
+            this.destination,
+            this.background,
+            this.source,
+            Amount,
+            this.coverage);
+
+        return this.destination[^1];
+    }
+
+    /// <summary>
+    /// Blends a constant source with one shared amount and per-pixel coverage.
+    /// </summary>
+    /// <returns>The final destination pixel.</returns>
+    [Benchmark]
+    public Vector4 ConstantSourceScalarAmountCoverage()
+    {
+        this.blender.BlendConstantSourceScalarAmountCoverage(
+            this.destination,
+            this.background,
+            this.constantSource,
+            Amount,
+            this.coverage);
+
+        return this.destination[^1];
+    }
+
+    /// <summary>
+    /// Blends a source row with per-pixel amounts and coverage.
+    /// </summary>
+    /// <returns>The final destination pixel.</returns>
+    [Benchmark]
+    public Vector4 SourceSpanAmountSpanCoverage()
+    {
+        this.blender.BlendSourceSpanAmountSpanCoverage(
+            this.destination,
+            this.background,
+            this.source,
+            this.amounts,
+            this.coverage);
+
+        return this.destination[^1];
+    }
+
+    /// <summary>
+    /// Blends a constant source with per-pixel amounts and coverage.
+    /// </summary>
+    /// <returns>The final destination pixel.</returns>
+    [Benchmark]
+    public Vector4 ConstantSourceAmountSpanCoverage()
+    {
+        this.blender.BlendConstantSourceAmountSpanCoverage(
+            this.destination,
+            this.background,
+            this.constantSource,
+            this.amounts,
+            this.coverage);
+
+        return this.destination[^1];
+    }
+
+    /// <summary>
+    /// Creates one non-constant RGBA sample.
+    /// </summary>
+    /// <param name="random">The deterministic value source.</param>
+    /// <returns>The sample pixel.</returns>
+    private static Vector4 CreatePixel(Random random)
+        => new(random.NextSingle(), random.NextSingle(), random.NextSingle(), random.NextSingle());
+
+    /// <summary>
+    /// Exposes the protected shared traversal overloads without adding benchmark hooks to production APIs.
+    /// </summary>
+    private sealed class ExposedNormalSrcOverBlender :
+        DefaultPixelBlender<RgbaVector, DefaultPixelBlenderOperators.NormalSrcOver>
+    {
+        /// <summary>
+        /// Invokes the source-span, scalar-amount traversal.
+        /// </summary>
+        /// <param name="destination">The destination vectors.</param>
+        /// <param name="background">The background vectors.</param>
+        /// <param name="source">The source vectors.</param>
+        /// <param name="amount">The shared source amount.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendSourceSpanScalarAmount(
+            Span<Vector4> destination,
+            ReadOnlySpan<Vector4> background,
+            ReadOnlySpan<Vector4> source,
+            float amount)
+            => this.BlendFunction(destination, background, source, amount);
+
+        /// <summary>
+        /// Invokes the constant-source, scalar-amount traversal.
+        /// </summary>
+        /// <param name="destination">The destination vectors.</param>
+        /// <param name="background">The background vectors.</param>
+        /// <param name="source">The constant source vector.</param>
+        /// <param name="amount">The shared source amount.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendConstantSourceScalarAmount(
+            Span<Vector4> destination,
+            ReadOnlySpan<Vector4> background,
+            Vector4 source,
+            float amount)
+            => this.BlendFunction(destination, background, source, amount);
+
+        /// <summary>
+        /// Invokes the source-span, amount-span traversal.
+        /// </summary>
+        /// <param name="destination">The destination vectors.</param>
+        /// <param name="background">The background vectors.</param>
+        /// <param name="source">The source vectors.</param>
+        /// <param name="amount">The per-pixel source amounts.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendSourceSpanAmountSpan(
+            Span<Vector4> destination,
+            ReadOnlySpan<Vector4> background,
+            ReadOnlySpan<Vector4> source,
+            ReadOnlySpan<float> amount)
+            => this.BlendFunction(destination, background, source, amount);
+
+        /// <summary>
+        /// Invokes the constant-source, amount-span traversal.
+        /// </summary>
+        /// <param name="destination">The destination vectors.</param>
+        /// <param name="background">The background vectors.</param>
+        /// <param name="source">The constant source vector.</param>
+        /// <param name="amount">The per-pixel source amounts.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendConstantSourceAmountSpan(
+            Span<Vector4> destination,
+            ReadOnlySpan<Vector4> background,
+            Vector4 source,
+            ReadOnlySpan<float> amount)
+            => this.BlendFunction(destination, background, source, amount);
+
+        /// <summary>
+        /// Invokes the source-span, scalar-amount traversal with coverage.
+        /// </summary>
+        /// <param name="destination">The destination vectors.</param>
+        /// <param name="background">The background vectors.</param>
+        /// <param name="source">The source vectors.</param>
+        /// <param name="amount">The shared source amount.</param>
+        /// <param name="coverage">The per-pixel coverage values.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendSourceSpanScalarAmountCoverage(
+            Span<Vector4> destination,
+            ReadOnlySpan<Vector4> background,
+            ReadOnlySpan<Vector4> source,
+            float amount,
+            ReadOnlySpan<float> coverage)
+            => this.BlendWithCoverageFunction(destination, background, source, amount, coverage);
+
+        /// <summary>
+        /// Invokes the constant-source, scalar-amount traversal with coverage.
+        /// </summary>
+        /// <param name="destination">The destination vectors.</param>
+        /// <param name="background">The background vectors.</param>
+        /// <param name="source">The constant source vector.</param>
+        /// <param name="amount">The shared source amount.</param>
+        /// <param name="coverage">The per-pixel coverage values.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendConstantSourceScalarAmountCoverage(
+            Span<Vector4> destination,
+            ReadOnlySpan<Vector4> background,
+            Vector4 source,
+            float amount,
+            ReadOnlySpan<float> coverage)
+            => this.BlendWithCoverageFunction(destination, background, source, amount, coverage);
+
+        /// <summary>
+        /// Invokes the source-span, amount-span traversal with coverage.
+        /// </summary>
+        /// <param name="destination">The destination vectors.</param>
+        /// <param name="background">The background vectors.</param>
+        /// <param name="source">The source vectors.</param>
+        /// <param name="amount">The per-pixel source amounts.</param>
+        /// <param name="coverage">The per-pixel coverage values.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendSourceSpanAmountSpanCoverage(
+            Span<Vector4> destination,
+            ReadOnlySpan<Vector4> background,
+            ReadOnlySpan<Vector4> source,
+            ReadOnlySpan<float> amount,
+            ReadOnlySpan<float> coverage)
+            => this.BlendWithCoverageFunction(destination, background, source, amount, coverage);
+
+        /// <summary>
+        /// Invokes the constant-source, amount-span traversal with coverage.
+        /// </summary>
+        /// <param name="destination">The destination vectors.</param>
+        /// <param name="background">The background vectors.</param>
+        /// <param name="source">The constant source vector.</param>
+        /// <param name="amount">The per-pixel source amounts.</param>
+        /// <param name="coverage">The per-pixel coverage values.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BlendConstantSourceAmountSpanCoverage(
+            Span<Vector4> destination,
+            ReadOnlySpan<Vector4> background,
+            Vector4 source,
+            ReadOnlySpan<float> amount,
+            ReadOnlySpan<float> coverage)
+            => this.BlendWithCoverageFunction(destination, background, source, amount, coverage);
+    }
+}
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs b/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
index a851e2fcf..448de9ec4 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelBlenderTests.cs
@@ -791,42 +791,104 @@ public class PixelBlenderTests
         ExerciseBlender(blender, background, source);
     }
 
+    /// <summary>
+    /// Exercises every bulk overload across vector-width boundaries and compares it with single-pixel composition.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="blender">The blender under test.</param>
+    /// <param name="background">The background pixel.</param>
+    /// <param name="source">The source pixel.</param>
     private static void ExerciseBlender<TPixel>(PixelBlender<TPixel> blender, TPixel background, TPixel source)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        float[] amount = [1F, 1F, 1F, 1F];
-        float[] coverage = [1F, 1F, 1F, 1F];
+        const float amount = .625F;
 
-        TPixel expected = blender.Blend(background, source, 1F);
+        float[] amounts = [0F, .125F, .375F, .625F, .875F, 1F, .5F];
+        float[] coverage = [1F, .8F, .6F, .4F, .2F, 0F, .5F];
 
-        TPixel[] destination = new TPixel[4];
-        TPixel[] backgroundSpan = [background, background, background, background];
-        TPixel[] sourceSpan = [source, source, source, source];
+        // Seven pixels exercise one AVX-512 batch plus three tails, or three AVX2 batches plus one tail.
+        TPixel[] destination = new TPixel[7];
+        TPixel[] expected = new TPixel[7];
+        TPixel[] backgroundSpan = [background, background, background, background, background, background, background];
+        TPixel[] sourceSpan = [source, source, source, source, source, source, source];
         Vector4[] sourceSpanBuffer = new Vector4[destination.Length * 3];
         Vector4[] constantSourceBuffer = new Vector4[destination.Length * 2];
 
-        blender.Blend<TPixel>(Configuration.Default, destination, backgroundSpan, sourceSpan, 1F, sourceSpanBuffer);
-        Assert.All(destination, x => Assert.Equal(expected, x));
-
-        blender.Blend(Configuration.Default, destination, backgroundSpan, source, 1F, constantSourceBuffer);
-        Assert.All(destination, x => Assert.Equal(expected, x));
+        Array.Fill(expected, blender.Blend(background, source, amount));
 
-        blender.Blend(Configuration.Default, destination, backgroundSpan, sourceSpan, amount, sourceSpanBuffer);
-        Assert.All(destination, x => Assert.Equal(expected, x));
+        blender.Blend<TPixel>(Configuration.Default, destination, backgroundSpan, sourceSpan, amount, sourceSpanBuffer);
+        Assert.Equal(expected, destination);
 
         blender.Blend(Configuration.Default, destination, backgroundSpan, source, amount, constantSourceBuffer);
-        Assert.All(destination, x => Assert.Equal(expected, x));
+        Assert.Equal(expected, destination);
 
-        blender.BlendWithCoverage<TPixel>(Configuration.Default, destination, backgroundSpan, sourceSpan, 1F, coverage, sourceSpanBuffer);
-        Assert.All(destination, x => Assert.Equal(expected, x));
+        for (int i = 0; i < expected.Length; i++)
+        {
+            expected[i] = blender.Blend(background, source, amounts[i]);
+        }
 
-        blender.BlendWithCoverage(Configuration.Default, destination, backgroundSpan, source, 1F, coverage, constantSourceBuffer);
-        Assert.All(destination, x => Assert.Equal(expected, x));
+        blender.Blend(Configuration.Default, destination, backgroundSpan, sourceSpan, amounts, sourceSpanBuffer);
+        Assert.Equal(expected, destination);
 
-        blender.BlendWithCoverage(Configuration.Default, destination, backgroundSpan, sourceSpan, amount, coverage, sourceSpanBuffer);
-        Assert.All(destination, x => Assert.Equal(expected, x));
+        blender.Blend(Configuration.Default, destination, backgroundSpan, source, amounts, constantSourceBuffer);
+        Assert.Equal(expected, destination);
+
+        for (int i = 0; i < expected.Length; i++)
+        {
+            expected[i] = BlendWithCoverageScalar(blender, background, source, amount, coverage[i]);
+        }
+
+        blender.BlendWithCoverage<TPixel>(Configuration.Default, destination, backgroundSpan, sourceSpan, amount, coverage, sourceSpanBuffer);
+        Assert.Equal(expected, destination);
 
         blender.BlendWithCoverage(Configuration.Default, destination, backgroundSpan, source, amount, coverage, constantSourceBuffer);
-        Assert.All(destination, x => Assert.Equal(expected, x));
+        Assert.Equal(expected, destination);
+
+        for (int i = 0; i < expected.Length; i++)
+        {
+            expected[i] = BlendWithCoverageScalar(blender, background, source, amounts[i], coverage[i]);
+        }
+
+        blender.BlendWithCoverage(Configuration.Default, destination, backgroundSpan, sourceSpan, amounts, coverage, sourceSpanBuffer);
+        Assert.Equal(expected, destination);
+
+        blender.BlendWithCoverage(Configuration.Default, destination, backgroundSpan, source, amounts, coverage, constantSourceBuffer);
+        Assert.Equal(expected, destination);
+    }
+
+    /// <summary>
+    /// Computes a one-pixel coverage result through the scalar remainder path.
+    /// </summary>
+    /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="blender">The blender under test.</param>
+    /// <param name="background">The background pixel.</param>
+    /// <param name="source">The source pixel.</param>
+    /// <param name="amount">The source opacity.</param>
+    /// <param name="coverage">The pixel coverage.</param>
+    /// <returns>The blended pixel.</returns>
+    private static TPixel BlendWithCoverageScalar<TPixel>(
+        PixelBlender<TPixel> blender,
+        TPixel background,
+        TPixel source,
+        float amount,
+        float coverage)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        Span<TPixel> destination = stackalloc TPixel[1];
+        Span<TPixel> backgroundSpan = stackalloc TPixel[1] { background };
+        Span<TPixel> sourceSpan = stackalloc TPixel[1] { source };
+        Span<float> coverageSpan = stackalloc float[1] { coverage };
+        Span<Vector4> buffer = stackalloc Vector4[3];
+
+        blender.BlendWithCoverage<TPixel>(
+            Configuration.Default,
+            destination,
+            backgroundSpan,
+            sourceSpan,
+            amount,
+            coverageSpan,
+            buffer);
+
+        return destination[0];
     }
 }